erosolar-cli 2.1.168 → 2.1.170

package/dist/shell/interactiveShell.js

@@ -7,7 +7,6 @@ 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';
@@ -19,7 +18,6 @@ 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';
@@ -136,7 +134,6 @@ export class InteractiveShell {
     lastContextWarningLevel = null;
     sessionPreferences;
     autosaveEnabled;
-    autoContinueEnabled;
     verificationEnabled = false;
     criticalApprovalMode = 'auto';
     editGuardMode = 'display-edits';
@@ -182,7 +179,6 @@ export class InteractiveShell {
     streamingOutputSuppressed = false;
     aiRuntimeStart = null;
     aiRuntimeTotalMs = 0;
-    streamingFormatter = null;
     streamingThoughtBuffer = '';
     statusLineState = null;
     statusMessageOverride = null;
@@ -207,7 +203,6 @@ 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;
@@ -284,6 +279,10 @@ 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,
@@ -297,13 +296,14 @@ 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(),
-            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();
@@ -447,18 +447,21 @@ export class InteractiveShell {
         const top = `╭${'─'.repeat(labelLeft)}${label}${'─'.repeat(labelRight)}╮`;
         const bottom = `╰${'─'.repeat(contentWidth)}╯`;
         const userName = process.env['USER'] || 'there';
-        const logo = clamp('⟣╍◎╍⟢');
+        const logo = '⟣╍◎╍⟢';
         const versionLabel = version ? clamp(`${brand} · v${version}`) : brand;
         const modelLine = clamp(model);
         const workspaceLine = clamp(workspace);
-        const welcomeLine = clamp(`Welcome back ${userName}!`);
+        // 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 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) {
@@ -469,8 +472,6 @@ 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);
     }
@@ -508,22 +509,32 @@ export class InteractiveShell {
     }
     async checkAndShowUpdates() {
         try {
-            const { checkForUpdates, formatUpdateNotification, maybeAutoUpdate } = await import('../core/updateChecker.js');
+            const { checkForUpdates, getUpdateDecision, formatUpdateBanner, performBackgroundUpdate, readAutoUpdateState, shouldShowUpdateNotification, } = 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;
             }
-            const updateResult = await maybeAutoUpdate(currentVersion, {
-                updateInfo,
-                logger: (message) => this.streamEventBlock(message),
-            });
-            if (updateResult?.updated) {
+            // 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
                 return;
             }
-            const note = this.describeUpdateSkipReason(updateResult);
-            const notification = formatUpdateNotification(updateInfo, note);
-            this.streamEventBlock(notification);
+            // 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
         }
         catch {
             // Silently fail - don't interrupt user experience
@@ -607,6 +618,8 @@ 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();
@@ -615,8 +628,9 @@ export class InteractiveShell {
         this.refreshControlBar();
         // Now sync renderer and control bar state
         this.syncRendererInput();
-        // Ensure the prompt/control bar is rendered after the welcome banner
-        this.ensureReadlineReady();
+        // CRITICAL: Force prompt render after banner - flushEvents should have done this,
+        // but explicitly ensure the prompt area is visible
+        this.renderer?.render();
         if (initialPrompt) {
             await this.enqueuePromptForProcessing(initialPrompt, 'programmatic');
             return;
@@ -624,7 +638,7 @@ export class InteractiveShell {
         this.showLaunchCommandPalette();
         // Ensure the terminal input is visible
         this.syncRendererInput();
-        this.ensureReadlineReady();
+        this.renderer?.render();
     }
     showLaunchCommandPalette() {
         // Disabled: Quick commands palette takes up too much space
@@ -692,6 +706,10 @@ 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();
         }
@@ -787,7 +805,6 @@ export class InteractiveShell {
             '/output-style',
             // Mode toggles
             '/thinking',
-            '/autocontinue',
             // Discovery and plugins
             '/local', '/discover',
             '/plugins',
@@ -877,25 +894,22 @@ export class InteractiveShell {
             : '🛡️ High-impact actions now require your approval. (Ctrl+Shift+A to toggle; use /approvals ask to persist)';
         display.showSystemMessage(message);
     }
-    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') {
+    /**
+     * 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;
         }
-        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.`);
+        // 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).
@@ -1049,6 +1063,13 @@ 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
      */
@@ -1618,9 +1639,7 @@ 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,
@@ -1711,15 +1730,14 @@ 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,
-            thinkingHasContent: display.isSpinnerActive(),
+            thinkingMs: null,
+            thinkingHasContent: false,
         });
         // Keep model/provider visible in the controls bar
         this.terminalInput.setModelContext({
@@ -1895,12 +1913,16 @@ 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;
-        // Suppress raw streaming lines; show only a single summary/status + final response
-        this.streamingOutputSuppressed = true;
+        this.streamingTokenCount = 0; // Reset token count for new prompt
+        // Show raw streaming output in real-time (Claude Code style)
+        this.streamingOutputSuppressed = false;
         const initialLabel = this.isMeaningfulStreamingSnippet(label)
             ? this.truncateStreamingLabel(label)
             : this.getStreamingFallbackLabel();
@@ -1944,6 +1966,8 @@ 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.';
@@ -1960,11 +1984,15 @@ 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
@@ -1973,37 +2001,32 @@ export class InteractiveShell {
         if (!processed.contentChunk && !processed.thinkingChunk) {
             return;
         }
-        // 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>')}`);
-        }
+        // 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.
         // 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 chunks bypass this so the thought process stays visible.
-        if (this.streamingOutputSuppressed && !isReasoning) {
+        // Reasoning tokens should also be suppressed and shown only in the indicator.
+        if (this.streamingOutputSuppressed) {
             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;
         }
-        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);
+        // Buffer all streaming content - rendered as complete block via onAssistantMessage
+        // This prevents fragmented display and ensures thinking tags are properly processed
         this.captureStreamingThought(contentChunk);
-        if (formatted) {
-            if (formatted.trim().length > 0) {
-                this.streamingContentSeen = true;
-            }
-            this.pushUiEvent('streaming', formatted);
-        }
+        // Activity: show what the model is doing (stable, informative)
+        this.renderer?.setActivity(type === 'reasoning' ? 'Reasoning' : 'Writing');
     }
     /**
      * Process streaming content to extract <thinking> blocks as separate events.
@@ -2051,22 +2074,12 @@ export class InteractiveShell {
         }
         return { thinkingChunk: thinkingContent, contentChunk: remainingContent };
     }
-    finishStreamingFormatter(note, options) {
-        if (!this.streamingFormatter) {
-            return;
-        }
-        const closing = this.streamingFormatter.finish({
-            note,
-            mode: options?.mode ?? 'complete',
-        });
-        if (closing) {
-            this.pushUiEvent('streaming', closing);
-        }
+    finishStreamingFormatter(_note, options) {
+        // Flush any remaining buffered thoughts
         if (this.streamingThoughtBuffer.trim()) {
             this.ui.controller.recordAssistantThought(this.streamingThoughtBuffer.trim());
         }
         this.streamingThoughtBuffer = '';
-        this.streamingFormatter = null;
         if (options?.refreshPrompt ?? true) {
             this.requestPromptRefresh(true);
         }
@@ -2405,9 +2418,6 @@ export class InteractiveShell {
                 case '/thinking':
                     this.handleThinkingCommand(input);
                     break;
-                case '/autocontinue':
-                    this.handleAutoContinueCommand(input);
-                    break;
                 case '/shortcuts':
                 case '/keys':
                     this.handleShortcutsCommand();
@@ -2511,6 +2521,9 @@ export class InteractiveShell {
                 case '/permissions':
                     this.handlePermissionsCommand();
                     break;
+                case '/update':
+                    await this.handleUpdateCommand(input);
+                    break;
                 case '/init':
                     this.handleInitCommand(input);
                     break;
@@ -2568,7 +2581,6 @@ 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')}`,
@@ -4282,20 +4294,6 @@ 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 = [];
@@ -4527,7 +4525,6 @@ 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')}`);
@@ -4683,6 +4680,67 @@ 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';
@@ -5707,6 +5765,7 @@ 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();
@@ -5721,6 +5780,7 @@ 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();
@@ -5776,8 +5836,6 @@ 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));
@@ -5848,6 +5906,7 @@ 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;
@@ -6255,43 +6314,6 @@ 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;
@@ -6672,21 +6694,41 @@ 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);
-                        const finalContent = parsed?.response?.trim() || 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 thoughtContent = parsed?.thinking?.trim() || null;
                         // Show the response if it wasn't already rendered during streaming
                         if (!streamedVisible) {
@@ -6789,12 +6831,6 @@ 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.');
@@ -6803,10 +6839,42 @@ 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();
@@ -6901,20 +6969,30 @@ 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 [
-                    '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>',
+                    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>.',
                 ].join('\n');
             case 'balanced':
             default:
-                return 'Balanced thinking mode: include a short <thinking>...</thinking> block before <response> when the reasoning is non-trivial; skip it for simple answers.';
+                return [
+                    baseRequirement,
+                    '',
+                    'Balanced mode: Keep thinking concise (2-4 sentences) but always present.',
+                ].join('\n');
         }
     }
     buildDisplayMetadata(metadata) {
@@ -7005,13 +7083,14 @@ Return ONLY JSON array:
             });
             cleanupOverlayActive = true;
             const triggerReason = trigger?.reason ?? 'Context optimization';
-            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(' '));
+            // 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 result = await contextManager.intelligentCompact(history);
             let afterStats = contextManager.getStats(result.compacted);
             let appliedHistory = result.compacted;
@@ -7038,10 +7117,18 @@ 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;
             }
@@ -7057,15 +7144,18 @@ Return ONLY JSON array:
             this.updateContextUsage(newPercentUsed, CONTEXT_AUTOCOMPACT_PERCENT);
             this.lastContextWarningLevel = this.getContextWarningLevel(newPercentUsed);
             this.refreshStatusLine(true);
-            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(' '));
+            // 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 ═');
+            }
             this.recordContextCompaction({
                 timestamp: Date.now(),
                 source: trigger?.source ?? 'auto',
@@ -7079,12 +7169,20 @@ 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;
         }
@@ -7386,28 +7484,6 @@ 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) {