erosolar-cli 2.1.167 → 2.1.168

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';
@@ -135,7 +137,6 @@ export class InteractiveShell {
     sessionPreferences;
     autosaveEnabled;
     autoContinueEnabled;
-    autoContinueEnforced = true;
     verificationEnabled = false;
     criticalApprovalMode = 'auto';
     editGuardMode = 'display-edits';
@@ -162,10 +163,6 @@ export class InteractiveShell {
     lastUserQuery = '';
     lastAssistantResponse = null;
     responseRendered = false;
-    autoContinueInsightState = {
-        attempt: 0,
-        lastMessage: null,
-    };
     lastFailure = null;
     lastAutoTestRun = null;
     // Auto-build tracking
@@ -185,6 +182,7 @@ export class InteractiveShell {
     streamingOutputSuppressed = false;
     aiRuntimeStart = null;
     aiRuntimeTotalMs = 0;
+    streamingFormatter = null;
     streamingThoughtBuffer = '';
     statusLineState = null;
     statusMessageOverride = null;
@@ -210,11 +208,6 @@ export class InteractiveShell {
         this.thinkingMode = this.sessionPreferences.thinkingMode;
         this.autosaveEnabled = this.sessionPreferences.autosave;
         this.autoContinueEnabled = this.sessionPreferences.autoContinue;
-        if (this.autoContinueEnforced && !this.autoContinueEnabled) {
-            // Project policy: keep auto-continue locked on to avoid stalls
-            this.autoContinueEnabled = true;
-            saveSessionPreferences({ autoContinue: true });
-        }
         this.criticalApprovalMode = this.sessionPreferences.criticalApprovalMode;
         const featureFlags = loadFeatureFlags();
         this.verificationEnabled = featureFlags.verification === true;
@@ -291,10 +284,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,
@@ -308,7 +297,6 @@ export class InteractiveShell {
             onQueue: (text) => this.handleQueuedInput(text),
             onCtrlC: ({ hadBuffer }) => this.handleCtrlCPress(hadBuffer),
             onInterrupt: () => this.handleInterrupt(),
-            onExit: () => this.handleExit(),
             onChange: ({ text, cursor }) => this.handleInputChange(text, cursor, 'renderer'),
             onEditModeChange: (mode) => this.handleEditModeChange(mode),
             onToggleVerify: () => this.toggleVerificationMode(),
@@ -316,7 +304,6 @@ export class InteractiveShell {
             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();
@@ -460,21 +447,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) {
@@ -485,6 +469,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);
     }
@@ -522,32 +508,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
@@ -631,8 +607,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();
@@ -641,9 +615,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;
@@ -651,7 +624,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
@@ -719,10 +692,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();
         }
@@ -908,49 +877,10 @@ export class InteractiveShell {
             : '🛡️ High-impact actions now require your approval. (Ctrl+Shift+A to toggle; use /approvals ask to persist)';
         display.showSystemMessage(message);
     }
-    enforceAutoContinuePolicy() {
-        if (!this.autoContinueEnforced) {
-            return;
-        }
-        if (!this.autoContinueEnabled) {
-            this.autoContinueEnabled = true;
-            saveSessionPreferences({ autoContinue: true });
-            if (this.agent) {
-                this.agent.setAutoContinue(true);
-            }
-            this.refreshControlBar();
-        }
-    }
-    resetAutoContinueInsights() {
-        this.autoContinueInsightState = { attempt: 0, lastMessage: null };
-    }
-    showAutoContinueInsight(attempt, maxAttempts, message) {
-        const normalized = (message || '').trim();
-        const isDuplicate = this.autoContinueInsightState.attempt === attempt &&
-            this.autoContinueInsightState.lastMessage === normalized;
-        if (isDuplicate) {
-            return;
-        }
-        this.autoContinueInsightState = { attempt, lastMessage: normalized };
-        const detail = normalized || 'Continuing automatically after intent without action.';
-        display.showSystemMessage(`Auto-continue ${attempt}/${maxAttempts}: ${detail}`);
-    }
     toggleAutoContinueMode() {
-        if (this.autoContinueEnforced) {
-            this.enforceAutoContinuePolicy();
-            display.showInfo('Auto-continue is enforced ON for erosolar-cli reliability and cannot be disabled.');
-            return;
-        }
         this.setAutoContinueMode(!this.autoContinueEnabled, 'shortcut');
     }
     setAutoContinueMode(enabled, source) {
-        if (this.autoContinueEnforced && !enabled) {
-            this.enforceAutoContinuePolicy();
-            if (source === 'command') {
-                display.showInfo('Auto-continue is enforced ON for erosolar-cli reliability and cannot be disabled.');
-            }
-            return;
-        }
         const changed = this.autoContinueEnabled !== enabled;
         this.autoContinueEnabled = enabled;
         saveSessionPreferences({ autoContinue: this.autoContinueEnabled });
@@ -967,23 +897,6 @@ export class InteractiveShell {
             : 'The model will not be auto-prompted to continue.';
         display.showInfo(`Auto-continue ${modeLabel}. ${behavior} Toggle with Ctrl+Shift+C.`);
     }
-    /**
-     * 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.');
-            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`);
-    }
     /**
      * Cycle through thinking modes (Tab shortcut).
      */
@@ -1136,13 +1049,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
      */
@@ -1805,14 +1711,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({
@@ -1988,16 +1895,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();
@@ -2041,8 +1944,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.';
@@ -2059,15 +1960,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
@@ -2076,32 +1973,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.
@@ -2149,12 +2051,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);
         }
@@ -2599,9 +2511,6 @@ export class InteractiveShell {
                 case '/permissions':
                     this.handlePermissionsCommand();
                     break;
-                case '/update':
-                    await this.handleUpdateCommand(input);
-                    break;
                 case '/init':
                     this.handleInitCommand(input);
                     break;
@@ -4378,21 +4287,13 @@ export class InteractiveShell {
         const value = tokens[0]?.toLowerCase();
         if (!value) {
             // Show current status
-            const lockedNote = this.autoContinueEnforced
-                ? ' (locked ON for erosolar-cli reliability)'
-                : ' Use /autocontinue on|off or Ctrl+Shift+C to toggle.';
-            display.showInfo(`Auto-continue is ${this.autoContinueEnabled ? 'enabled' : 'disabled'}.${lockedNote}`);
+            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;
         }
-        if (value === 'off' && this.autoContinueEnforced) {
-            this.enforceAutoContinuePolicy();
-            display.showInfo('Auto-continue is enforced ON for erosolar-cli reliability and cannot be disabled.');
-            return;
-        }
         this.setAutoContinueMode(value === 'on', 'command');
     }
     // ==================== Erosolar-CLI Style Commands ====================
@@ -4626,9 +4527,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')}`);
-        const autoContinueStatus = this.autoContinueEnabled ? 'on' : 'off';
-        const autoContinueLabel = this.autoContinueEnforced ? `${autoContinueStatus} (locked)` : autoContinueStatus;
-        lines.push(`${theme.primary('Auto-continue')}: ${this.autoContinueEnabled ? theme.success(autoContinueLabel) : theme.ui.muted(autoContinueLabel)}`);
+        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')}`);
@@ -4784,67 +4683,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';
@@ -5840,9 +5678,6 @@ export class InteractiveShell {
         this.clearInlinePanel();
         this.syncRendererInput();
     }
-    // NOTE: emitPromptAcknowledgement has been removed - acknowledgement is now handled
-    // by the onRequestReceived callback in agent.send(), which fires IMMEDIATELY when
-    // the request is received, guaranteeing instant user feedback before any processing.
     async processRequest(request) {
         if (this.isProcessing) {
             this.enqueueFollowUpAction({ type: 'request', text: request });
@@ -5858,8 +5693,6 @@ export class InteractiveShell {
         if (!agent) {
             return;
         }
-        this.enforceAutoContinuePolicy();
-        this.resetAutoContinueInsights();
         this.runtimeSession.toolRuntime.clearDiffSnapshots?.();
         if (this.suppressNextNetworkReset) {
             this.suppressNextNetworkReset = false;
@@ -5874,7 +5707,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();
@@ -5889,9 +5721,6 @@ export class InteractiveShell {
         this.currentTaskType = classifyTaskType(request);
         this.currentToolCalls = [];
         this.clearToolUsageMeta();
-        // NOTE: Acknowledgement is now handled by onRequestReceived callback in agent.send()
-        // This fires IMMEDIATELY when the request is received, before any provider call
-        this.renderer?.setActivity('Starting...');
         this.uiAdapter.startProcessing('Working on your request');
         this.setProcessingStatus();
         this.beginAiRuntime();
@@ -5947,6 +5776,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));
@@ -6013,13 +5844,10 @@ export class InteractiveShell {
         if (!agent) {
             return;
         }
-        this.enforceAutoContinuePolicy();
-        this.resetAutoContinueInsights();
         this.lastUserQuery = initialRequest;
         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;
@@ -6037,7 +5865,6 @@ export class InteractiveShell {
         completionDetector.reset();
         // Display user prompt in scrollback (Claude Code style)
         this.logUserPrompt(initialRequest);
-        // NOTE: Acknowledgement is now handled by onRequestReceived callback in agent.send()
         display.showSystemMessage(`Continuous mode active. Ctrl+C to stop.`);
         this.uiAdapter.startProcessing('Continuous execution mode');
         this.setProcessingStatus();
@@ -6074,8 +5901,6 @@ When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
                     // Send the request and capture the response (streaming disabled)
                     display.showThinking('Responding...');
                     this.refreshStatusLine(true);
-                    this.enforceAutoContinuePolicy();
-                    this.resetAutoContinueInsights();
                     const response = await agent.send(currentPrompt, true);
                     this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
                     await this.awaitPendingCleanup();
@@ -6430,6 +6255,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;
@@ -6782,8 +6644,6 @@ Return ONLY JSON array:
             // Send the error to the agent for fixing
             display.showThinking('Analyzing build errors');
             this.refreshStatusLine(true);
-            this.enforceAutoContinuePolicy();
-            this.resetAutoContinueInsights();
             const response = await this.agent.send(prompt, true);
             display.stopThinking();
             this.refreshStatusLine(true);
@@ -6803,7 +6663,6 @@ Return ONLY JSON array:
     rebuildAgent() {
         try {
             ensureSecretForProvider(this.sessionState.provider);
-            this.enforceAutoContinuePolicy();
             this.runtimeSession.updateToolContext(this.sessionState);
             this.ensureActiveSummarizer(this.runtimeSession.contextManager);
             const selection = {
@@ -6819,39 +6678,27 @@ Return ONLY JSON array:
                 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;
-                    const displaySuppressed = metadata.suppressDisplay === true;
                     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) {
                             if (thoughtContent) {
-                                if (!displaySuppressed) {
-                                    const summary = this.extractThoughtSummary(thoughtContent);
-                                    if (summary) {
-                                        display.updateThinking(`💭 ${summary}`);
-                                    }
-                                    display.showAssistantMessage(thoughtContent, { ...enriched, isFinal: false });
-                                    renderedFinal = true;
+                                const summary = this.extractThoughtSummary(thoughtContent);
+                                if (summary) {
+                                    display.updateThinking(`💭 ${summary}`);
                                 }
+                                display.showAssistantMessage(thoughtContent, { ...enriched, isFinal: false });
+                                renderedFinal = true;
                             }
-                            if (finalContent && !displaySuppressed) {
+                            if (finalContent) {
                                 display.showAssistantMessage(finalContent, enriched);
                                 renderedFinal = true;
                             }
@@ -6869,7 +6716,7 @@ Return ONLY JSON array:
                                 this.updateContextUsage(percentage);
                             }
                         }
-                        if (finalContent && !displaySuppressed) {
+                        if (finalContent) {
                             this.lastAssistantResponse = finalContent;
                         }
                         // Track thought + response as a single response event for telemetry
@@ -6891,7 +6738,7 @@ Return ONLY JSON array:
                         // Stop spinner and show the narrative text directly
                         display.stopThinking();
                         // Skip display if content was already streamed to avoid double-display
-                        if (!streamedVisible && !displaySuppressed) {
+                        if (!streamedVisible) {
                             const narrative = content.trim();
                             if (narrative) {
                                 display.showNarrative(narrative);
@@ -6942,10 +6789,11 @@ Return ONLY JSON array:
                     this.updateStatusMessage('Retrying with reduced context...');
                     this.syncRendererInput();
                 },
-                onAutoContinue: (attempt, maxAttempts, message) => {
-                    // Surface insight about why auto-continue fired while keeping UX responsive
-                    this.renderer?.setActivity('Continuing...');
-                    this.showAutoContinueInsight(attempt, maxAttempts, message);
+                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
@@ -6955,79 +6803,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');
-                    }
-                },
-                onBeforeFirstToolCall: (toolNames, hasModelNarration) => {
-                    // ALWAYS inject acknowledgement - even if model provided narration
-                    // This ensures user always sees immediate feedback that their request was received
-                    // The acknowledgement appears BEFORE any tool output
-                    const primaryTool = toolNames[0] || 'tools';
-                    const toolDescriptions = {
-                        'list_files': 'Looking at the project files...',
-                        'Glob': 'Searching for files...',
-                        'read_file': 'Reading the file...',
-                        'Read': 'Reading the file...',
-                        'execute_bash': 'Running command...',
-                        'Bash': 'Running command...',
-                        'grep_search': 'Searching the code...',
-                        'Grep': 'Searching the code...',
-                        'write_file': 'Writing the file...',
-                        'Write': 'Writing the file...',
-                        'edit_file': 'Editing the file...',
-                        'Edit': 'Editing the file...',
-                        'WebFetch': 'Fetching web content...',
-                        'WebSearch': 'Searching the web...',
-                        'Task': 'Starting task...',
-                    };
-                    // Return acknowledgement regardless of hasModelNarration
-                    // If model provided narration, it will appear after this acknowledgement
-                    return toolDescriptions[primaryTool] || 'Running tools to advance your request...';
-                },
                 onVerificationNeeded: (response, context) => {
                     this.lastAssistantResponse = response;
                     void this.runAutoQualityChecks('verification', response, context);
                 },
-                // NEW: Immediate acknowledgement when request is received (BEFORE provider call)
-                onRequestReceived: (requestPreview) => {
-                    // This fires IMMEDIATELY when user submits request, guaranteeing instant feedback
-                    // The message appears before any AI processing begins
-                    const normalized = requestPreview?.trim();
-                    const message = normalized
-                        ? `⚡ Acknowledged — focusing on "${normalized}" and acting now.`
-                        : '⚡ Acknowledged — acting now.';
-                    display.showAssistantMessage(message, { isFinal: false });
-                    this.renderer?.setActivity('Acknowledged');
-                },
-                // NEW: 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();
@@ -7122,30 +6901,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) {
@@ -7236,14 +7005,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;
@@ -7270,18 +7038,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;
             }
@@ -7297,18 +7057,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',
@@ -7322,20 +7079,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;
         }
@@ -7637,6 +7386,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) {