erosolar-cli 1.7.383 → 1.7.386

package/dist/shell/interactiveShell.js

@@ -70,6 +70,9 @@ const PROVIDER_LABELS = Object.fromEntries(getProviders().map((provider) => [pro
 // Allow enough time for paste detection to kick in before flushing buffered lines
 const CONTEXT_USAGE_THRESHOLD = 0.9;
 const CONTEXT_AUTOCOMPACT_PERCENT = Math.round(CONTEXT_USAGE_THRESHOLD * 100);
+const CONTEXT_AUTOCOMPACT_FLOOR = 0.6;
+const MIN_COMPACTION_TOKEN_SAVINGS = 200;
+const MIN_COMPACTION_PERCENT_SAVINGS = 0.5;
 const CONTEXT_RECENT_MESSAGE_COUNT = 12;
 const CONTEXT_CLEANUP_CHARS_PER_CHUNK = 6000;
 const CONTEXT_CLEANUP_MAX_OUTPUT_TOKENS = 800;
@@ -99,6 +102,8 @@ export class InteractiveShell {
     pendingCleanup = null;
     cleanupInProgress = false;
     slashPreviewVisible = false;
+    lastLoggedPrompt = null;
+    lastLoggedPromptAt = 0;
     skillRepository;
     skillToolHandlers = new Map();
     thinkingMode = 'balanced';
@@ -116,6 +121,9 @@ export class InteractiveShell {
     isDrainingQueue = false;
     activeContextWindowTokens = null;
     latestTokenUsage = { used: null, limit: null };
+    planApprovalBridgeRegistered = false;
+    contextCompactionInFlight = false;
+    lastContextWarningLevel = null;
     sessionPreferences;
     autosaveEnabled;
     autoContinueEnabled;
@@ -145,9 +153,12 @@ export class InteractiveShell {
     autoBuildInFlight = false;
     lastAutoBuildRun = null;
     // Streaming UX tracking
+    batchedOutputMode;
     streamingHeartbeatStart = null;
     streamingHeartbeatFrame = 0;
     streamingStatusLabel = null;
+    streamingUiActive = false;
+    pendingStreamBuffer = '';
     lastStreamingElapsedSeconds = null; // Preserve final elapsed time
     statusLineState = null;
     statusMessageOverride = null;
@@ -169,6 +180,8 @@ export class InteractiveShell {
         this.sessionRestoreConfig = config.sessionRestore ?? { mode: 'none' };
         this._enabledPlugins = config.enabledPlugins ?? [];
         this.version = config.version ?? '0.0.0';
+        const streamingEnv = process.env['EROSOLAR_STREAMING_UI']?.toLowerCase();
+        this.batchedOutputMode = streamingEnv !== 'on' && streamingEnv !== 'true' && streamingEnv !== '1';
         // Alternate screen disabled - use terminal-native mode for proper scrollback and text selection
         this.alternateScreenEnabled = false;
         this.initializeSessionHistory();
@@ -255,6 +268,11 @@ export class InteractiveShell {
         this.refreshContextGauge();
         // Start terminal input (sets up handlers)
         this.terminalInput.start();
+        // Allow planning tools (e.g., ProposePlan) to open the interactive approval UI just like Codex CLI
+        this.registerPlanApprovalBridge();
+        // Capture display output into the scrollback/chat log so system messages
+        // (e.g., /evolve) render above the pinned chat box.
+        this.terminalInput.registerOutputInterceptor(display);
         // Set up command autocomplete with all slash commands
         this.setupCommandAutocomplete();
         // Enter alternate screen buffer when enabled, otherwise clear the main screen for layout
@@ -266,7 +284,7 @@ export class InteractiveShell {
         }
         // Stream banner first - this sets up scroll region dynamically
         const banner = this.buildBanner();
-        this.terminalInput.streamContent(banner + '\n\n');
+        this.terminalInput.streamContent(banner + '\n');
         // Render chat box after banner is streamed
         this.refreshControlBar();
         this.terminalInput.forceRender();
@@ -360,7 +378,6 @@ export class InteractiveShell {
             void maybeOfferCliUpdate(this.version);
         }
         if (initialPrompt) {
-            this.logUserPrompt(initialPrompt);
             await this.processInputBlock(initialPrompt);
             return;
         }
@@ -388,7 +405,6 @@ export class InteractiveShell {
         }
         // DON'T clear the input here - keep it visible while streaming.
         // The input will be cleared after streaming completes in the finally block.
-        this.logUserPrompt(approved);
         void this.processInputBlock(approved).catch((err) => {
             display.showError(err instanceof Error ? err.message : String(err), err);
         });
@@ -505,15 +521,9 @@ export class InteractiveShell {
         this.editGuardMode = mode;
         this.pendingPermissionInput = null;
         if (mode === 'plan') {
-            // Register plan approval callback for interactive UI
-            setPlanApprovalCallback((steps, explanation) => {
-                this.showPlanApproval(steps, explanation);
-            });
             display.showSystemMessage('📋 Plan mode enabled. AI will create a plan and ask for approval before implementing.');
         }
         else {
-            // Unregister callback when not in plan mode
-            setPlanApprovalCallback(null);
             if (mode === 'ask-permission') {
                 display.showSystemMessage('🛡️ Ask-to-edit mode enabled. Confirm each request before sending.');
             }
@@ -729,6 +739,8 @@ export class InteractiveShell {
         if (this.alternateScreenEnabled) {
             this.terminalInput.exitAlternateScreen();
         }
+        // Unregister plan approval bridge
+        setPlanApprovalCallback(null);
         // Dispose terminal input handler
         this.terminalInput.dispose();
         // Dispose unified UI adapter
@@ -752,6 +764,18 @@ export class InteractiveShell {
         // Write directly to stdout after exiting alternate screen to preserve the transcript
         process.stdout.write(`\n${separator}\n${header}\n${transcript}\n${separator}\n`);
     }
+    /**
+     * Wire the planning tool suite to the interactive plan approval UI so ProposePlan behaves like Codex CLI.
+     */
+    registerPlanApprovalBridge() {
+        if (this.planApprovalBridgeRegistered) {
+            return;
+        }
+        setPlanApprovalCallback((steps, explanation) => {
+            this.showPlanApproval(steps, explanation);
+        });
+        this.planApprovalBridgeRegistered = true;
+    }
     /**
      * Update status bar message
      */
@@ -760,6 +784,21 @@ export class InteractiveShell {
         // During streaming we still want the spinner prefix; when idle force a fast refresh.
         this.refreshStatusLine(!this.isProcessing);
     }
+    /**
+     * Inline menu/panel helpers (rendered in TerminalInput, not in scrollback).
+     */
+    showInlineMenu(title, lines, tone = 'info', hint) {
+        const merged = [...lines];
+        if (hint) {
+            merged.push('', tone === 'error' ? theme.error(hint) : theme.warning(hint));
+        }
+        this.terminalInput.setInlinePanel({ title, lines: merged, tone });
+        this.terminalInput.render();
+    }
+    clearInlineMenu() {
+        this.terminalInput.setInlinePanel(null);
+        this.terminalInput.render();
+    }
     async handleToolSettingsInput(input) {
         const pending = this.pendingInteraction;
         if (!pending || pending.type !== 'tool-settings') {
@@ -1105,9 +1144,9 @@ export class InteractiveShell {
             };
         }
     }
-    updateContextUsage(percentage) {
+    updateContextUsage(percentage, autoCompactThreshold = CONTEXT_AUTOCOMPACT_PERCENT) {
         this.uiAdapter.updateContextUsage(percentage);
-        this.terminalInput.setContextUsage(percentage, CONTEXT_AUTOCOMPACT_PERCENT);
+        this.terminalInput.setContextUsage(percentage, autoCompactThreshold);
     }
     refreshControlBar() {
         this.terminalInput.setModeToggles({
@@ -1190,10 +1229,6 @@ export class InteractiveShell {
         if (state.detail) {
             parts.push(state.detail);
         }
-        const elapsedSeconds = Math.max(0, Math.floor((Date.now() - state.startedAt) / 1000));
-        if (elapsedSeconds > 0) {
-            parts.push(`${elapsedSeconds}s`);
-        }
         return parts.join(' • ');
     }
     handleSlashCommandPreviewChange() {
@@ -1240,10 +1275,18 @@ export class InteractiveShell {
      * Log user prompt to the scroll region so it's part of the conversation flow.
      */
     logUserPrompt(text) {
-        if (!text.trim())
+        const normalized = text.trim();
+        if (!normalized)
+            return;
+        // Skip duplicate renders of the exact same prompt if they happen back-to-back.
+        const now = Date.now();
+        if (this.lastLoggedPrompt === normalized && now - this.lastLoggedPromptAt < 2000) {
             return;
+        }
+        this.lastLoggedPrompt = normalized;
+        this.lastLoggedPromptAt = now;
         // Format with user prompt prefix and write to scroll region
-        const formatted = `${theme.user('>')} ${text}\n`;
+        const formatted = `${theme.user('>')} ${normalized}\n`;
         this.terminalInput.writeToScrollRegion(formatted);
     }
     requestPromptRefresh(force = false) {
@@ -1265,17 +1308,49 @@ export class InteractiveShell {
             this.promptRefreshTimer = null;
         }
     }
+    resetStreamBuffer() {
+        this.pendingStreamBuffer = '';
+    }
+    captureStreamChunk(chunk) {
+        if (!this.batchedOutputMode || !chunk) {
+            return;
+        }
+        this.pendingStreamBuffer += chunk;
+    }
+    consumeStreamBuffer(fallback) {
+        if (!this.batchedOutputMode) {
+            return fallback;
+        }
+        const buffered = this.pendingStreamBuffer;
+        this.pendingStreamBuffer = '';
+        return buffered || fallback;
+    }
+    currentRunElapsedMs() {
+        if (!this.streamingHeartbeatStart) {
+            return undefined;
+        }
+        return Date.now() - this.streamingHeartbeatStart;
+    }
     startStreamingHeartbeat(label = 'Streaming') {
         this.stopStreamingHeartbeat();
-        // Enter global streaming mode - blocks all non-streaming UI output
-        enterStreamingMode();
-        // Set up scroll region for streaming content
-        this.terminalInput.enterStreamingScrollRegion();
-        this.uiUpdates.setMode('streaming');
+        this.resetStreamBuffer();
+        this.lastStreamingElapsedSeconds = null;
         this.streamingHeartbeatStart = Date.now();
         this.streamingHeartbeatFrame = 0;
         const initialFrame = STREAMING_SPINNER_FRAMES[this.streamingHeartbeatFrame];
         this.streamingStatusLabel = this.buildStreamingStatus(`${initialFrame} ${label}`, 0);
+        if (this.batchedOutputMode) {
+            this.streamingUiActive = false;
+            this.uiUpdates.setMode('processing');
+        }
+        else {
+            // Enter global streaming mode - blocks all non-streaming UI output
+            enterStreamingMode();
+            // Set up scroll region for streaming content
+            this.terminalInput.enterStreamingScrollRegion();
+            this.streamingUiActive = true;
+            this.uiUpdates.setMode('streaming');
+        }
         display.updateStreamingStatus(this.streamingStatusLabel);
         this.refreshStatusLine(true);
         // Periodically refresh the pinned input/status region while streaming so
@@ -1305,18 +1380,21 @@ export class InteractiveShell {
         });
     }
     stopStreamingHeartbeat() {
-        // Exit global streaming mode - allows UI to render again
-        exitStreamingMode();
         // Preserve final elapsed time before clearing heartbeat start
         if (this.streamingHeartbeatStart) {
             this.lastStreamingElapsedSeconds = Math.max(0, Math.floor((Date.now() - this.streamingHeartbeatStart) / 1000));
         }
-        // Exit scroll region mode
-        this.terminalInput.exitStreamingScrollRegion();
+        if (this.streamingUiActive) {
+            // Exit global streaming mode - allows UI to render again
+            exitStreamingMode();
+            // Exit scroll region mode
+            this.terminalInput.exitStreamingScrollRegion();
+        }
         this.uiUpdates.stopHeartbeat('streaming');
         this.streamingHeartbeatStart = null;
         this.streamingHeartbeatFrame = 0;
         this.streamingStatusLabel = null;
+        this.streamingUiActive = false;
         // Clear streaming label specifically (keeps override and main status if set)
         this.terminalInput.setStreamingLabel(null);
         // Clear streaming status from display
@@ -1324,20 +1402,11 @@ export class InteractiveShell {
         // Force refresh to update the input area now that streaming has ended
         this.refreshStatusLine(true);
     }
-    buildStreamingStatus(label, elapsedSeconds) {
-        const detail = this.describeModelDetail();
-        const elapsedLabel = typeof elapsedSeconds === 'number' && elapsedSeconds >= 0
-            ? theme.ui.muted(this.formatElapsedShort(elapsedSeconds))
-            : null;
+    buildStreamingStatus(label, _elapsedSeconds) {
+        // Model + elapsed time already live in the pinned meta header; keep the streaming
+        // status focused on the activity to avoid duplicate info.
         const prefix = theme.info('⏺');
-        const parts = [label];
-        if (detail) {
-            parts.push(theme.ui.muted('·'), detail);
-        }
-        if (elapsedLabel) {
-            parts.push(theme.ui.muted('·'), elapsedLabel);
-        }
-        return `${prefix} ${parts.join(' ')}`.trim();
+        return `${prefix} ${label}`.trim();
     }
     formatElapsedShort(seconds) {
         if (seconds < 60) {
@@ -1493,6 +1562,10 @@ export class InteractiveShell {
             return false;
         }
         switch (this.pendingInteraction.type) {
+            case 'model-loading':
+                display.showInfo('Still fetching model options. Please wait a moment.');
+                this.terminalInput.render();
+                return true;
             case 'model-provider':
                 await this.handleModelProviderSelection(input);
                 return true;
@@ -3627,28 +3700,25 @@ export class InteractiveShell {
         return lines.join('\n');
     }
     async showModelMenu() {
-        display.showSystemMessage(theme.ui.muted('Fetching latest models from providers...'));
-        // Fetch live models from all configured providers
-        const providerStatuses = await quickCheckProviders();
-        const providerOptions = this.buildProviderOptionsWithDiscovery(providerStatuses);
-        if (!providerOptions.length) {
-            display.showWarning('No providers are available.');
-            return;
+        // Hold input immediately so numeric selections don't get queued as prompts while we fetch
+        this.pendingInteraction = { type: 'model-loading' };
+        this.showInlineMenu('Model provider', [theme.ui.muted('Fetching latest models from providers...')], 'info');
+        try {
+            // Fetch live models from all configured providers
+            const providerStatuses = await quickCheckProviders();
+            const providerOptions = this.buildProviderOptionsWithDiscovery(providerStatuses);
+            if (!providerOptions.length) {
+                this.pendingInteraction = null;
+                this.showInlineMenu('Model provider', [theme.warning('No providers are available.')], 'warning');
+                return;
+            }
+            this.pendingInteraction = { type: 'model-provider', options: providerOptions };
+            this.renderProviderMenu(providerOptions);
+        }
+        catch (error) {
+            this.pendingInteraction = null;
+            this.showInlineMenu('Model provider', [theme.error('Failed to load model list. Try again in a moment.')], 'error');
         }
-        const lines = [
-            theme.bold('Select a provider:'),
-            ...providerOptions.map((option, index) => {
-                const isCurrent = option.provider === this.sessionState.provider;
-                const countLabel = `${option.modelCount} model${option.modelCount === 1 ? '' : 's'}`;
-                const latestLabel = option.latestModel ? theme.success(` (latest: ${option.latestModel})`) : '';
-                const label = this.colorizeDropdownLine(`${index + 1}. ${option.label} — ${countLabel}${latestLabel}`, index);
-                const suffix = isCurrent ? ` ${theme.primary('• current')}` : '';
-                return `${label}${suffix}`;
-            }),
-            'Type the number of the provider to continue, or type "cancel".',
-        ];
-        display.showSystemMessage(lines.join('\n'));
-        this.pendingInteraction = { type: 'model-provider', options: providerOptions };
     }
     buildProviderOptions() {
         const counts = new Map();
@@ -3738,6 +3808,21 @@ export class InteractiveShell {
             };
         });
     }
+    renderProviderMenu(options, hint) {
+        const lines = [
+            theme.bold('Select a provider:'),
+            ...options.map((option, index) => {
+                const isCurrent = option.provider === this.sessionState.provider;
+                const countLabel = `${option.modelCount} model${option.modelCount === 1 ? '' : 's'}`;
+                const latestLabel = option.latestModel ? theme.success(` (latest: ${option.latestModel})`) : '';
+                const label = this.colorizeDropdownLine(`${index + 1}. ${option.label} — ${countLabel}${latestLabel}`, index);
+                const suffix = isCurrent ? ` ${theme.primary('• current')}` : '';
+                return `${label}${suffix}`;
+            }),
+            'Type the number of the provider to continue, or type "cancel".',
+        ];
+        this.showInlineMenu('Model provider', lines, 'info', hint);
+    }
     showProviderModels(option) {
         // Start with static presets
         const staticModels = MODEL_PRESETS.filter((preset) => preset.provider === option.provider);
@@ -3777,13 +3862,17 @@ export class InteractiveShell {
             }
         }
         if (!allModels.length) {
-            display.showWarning(`No models available for ${option.label}.`);
+            this.showInlineMenu('Model selection', [theme.warning(`No models available for ${option.label}.`)], 'warning');
             this.pendingInteraction = null;
             return;
         }
+        this.renderModelSelection(allModels, option, null);
+        this.pendingInteraction = { type: 'model', provider: option.provider, options: allModels };
+    }
+    renderModelSelection(models, option, hint) {
         const lines = [
             theme.bold(`Select a model from ${option.label}:`),
-            ...allModels.map((preset, index) => {
+            ...models.map((preset, index) => {
                 const isCurrent = preset.id === this.sessionState.model;
                 const isLatest = preset.id === option.latestModel;
                 const latestBadge = isLatest ? theme.success(' ★ LATEST') : '';
@@ -3794,11 +3883,23 @@ export class InteractiveShell {
             }),
             'Type the number of the model to select it, type "back" to change provider, or type "cancel".',
         ];
-        display.showSystemMessage(lines.join('\n'));
-        this.pendingInteraction = { type: 'model', provider: option.provider, options: allModels };
+        this.showInlineMenu('Model selection', lines, 'info', hint ?? undefined);
+    }
+    buildProviderContext(provider, models) {
+        return {
+            provider,
+            label: this.providerLabel(provider),
+            modelCount: models.length,
+            latestModel: models[0]?.id,
+            discoveredModels: [],
+        };
     }
     showSecretsMenu() {
         const definitions = listSecretDefinitions();
+        this.pendingInteraction = { type: 'secret-select', options: definitions };
+        this.renderSecretsMenu(definitions);
+    }
+    renderSecretsMenu(definitions, hint) {
         const lines = [
             theme.bold('Manage Secrets:'),
             ...definitions.map((definition, index) => {
@@ -3810,8 +3911,18 @@ export class InteractiveShell {
             }),
             'Enter the number to update a key, or type "cancel".',
         ];
-        display.showSystemMessage(lines.join('\n'));
-        this.pendingInteraction = { type: 'secret-select', options: definitions };
+        this.showInlineMenu('Secrets', lines, 'info', hint);
+    }
+    renderSecretInput(secret, hint) {
+        const value = getSecretValue(secret.id);
+        const status = value ? maskSecret(value) : theme.warning('not set');
+        const providers = secret.providers.map((id) => this.providerLabel(id)).join(', ');
+        const lines = [
+            `${secret.label} (${providers})`,
+            `Current: ${status}`,
+            'Enter a new value or type "cancel".',
+        ];
+        this.showInlineMenu('Update secret', lines, 'info', hint);
     }
     showToolsMenu() {
         const options = getToolToggleOptions();
@@ -4191,26 +4302,23 @@ export class InteractiveShell {
         }
         const trimmed = input.trim();
         if (!trimmed) {
-            display.showWarning('Enter a number or type cancel.');
-            this.terminalInput.render();
+            this.renderProviderMenu(pending.options, 'Enter a number or type cancel.');
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
-            display.showInfo('Model selection cancelled.');
-            this.terminalInput.render();
+            this.clearInlineMenu();
+            this.updateStatusMessage('Model selection cancelled.');
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
         if (!Number.isFinite(choice)) {
-            display.showWarning('Please enter a valid number.');
-            this.terminalInput.render();
+            this.renderProviderMenu(pending.options, 'Please enter a valid number.');
             return;
         }
         const option = pending.options[choice - 1];
         if (!option) {
-            display.showWarning('That option is not available.');
-            this.terminalInput.render();
+            this.renderProviderMenu(pending.options, 'That option is not available.');
             return;
         }
         this.showProviderModels(option);
@@ -4221,10 +4329,10 @@ export class InteractiveShell {
         if (!pending || pending.type !== 'model') {
             return;
         }
+        const providerContext = this.buildProviderContext(pending.provider, pending.options);
         const trimmed = input.trim();
         if (!trimmed) {
-            display.showWarning('Enter a number, type "back", or type "cancel".');
-            this.terminalInput.render();
+            this.renderModelSelection(pending.options, providerContext, 'Enter a number, type "back", or type "cancel".');
             return;
         }
         if (trimmed.toLowerCase() === 'back') {
@@ -4234,20 +4342,18 @@ export class InteractiveShell {
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
-            display.showInfo('Model selection cancelled.');
-            this.terminalInput.render();
+            this.clearInlineMenu();
+            this.updateStatusMessage('Model selection cancelled.');
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
         if (!Number.isFinite(choice)) {
-            display.showWarning('Please enter a valid number.');
-            this.terminalInput.render();
+            this.renderModelSelection(pending.options, providerContext, 'Please enter a valid number.');
             return;
         }
         const preset = pending.options[choice - 1];
         if (!preset) {
-            display.showWarning('That option is not available.');
-            this.terminalInput.render();
+            this.renderModelSelection(pending.options, providerContext, 'That option is not available.');
             return;
         }
         this.pendingInteraction = null;
@@ -4271,11 +4377,14 @@ export class InteractiveShell {
         };
         this.applyPresetReasoningDefaults();
         if (this.rebuildAgent()) {
-            display.showInfo(`Switched to ${preset.label}.`);
+            this.showInlineMenu('Model updated', [`Switched to ${preset.label}.`], 'success');
             this.refreshBannerSessionInfo();
             this.persistSessionPreference();
             this.resetChatBoxAfterModelSwap();
         }
+        else {
+            this.showInlineMenu('Model updated', [`Using ${preset.label}.`], 'info');
+        }
     }
     async handleSecretSelection(input) {
         const pending = this.pendingInteraction;
@@ -4284,30 +4393,27 @@ export class InteractiveShell {
         }
         const trimmed = input.trim();
         if (!trimmed) {
-            display.showWarning('Enter a number or type cancel.');
-            this.terminalInput.render();
+            this.renderSecretsMenu(pending.options, 'Enter a number or type cancel.');
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
-            display.showInfo('Secret management cancelled.');
-            this.terminalInput.render();
+            this.clearInlineMenu();
+            this.updateStatusMessage('Secret management cancelled.');
             return;
         }
         const choice = Number.parseInt(trimmed, 10);
         if (!Number.isFinite(choice)) {
-            display.showWarning('Please enter a valid number.');
-            this.terminalInput.render();
+            this.renderSecretsMenu(pending.options, 'Please enter a valid number.');
             return;
         }
         const secret = pending.options[choice - 1];
         if (!secret) {
-            display.showWarning('That option is not available.');
-            this.terminalInput.render();
+            this.renderSecretsMenu(pending.options, 'That option is not available.');
             return;
         }
-        display.showSystemMessage(`Enter a new value for ${secret.label} or type "cancel".`);
         this.pendingInteraction = { type: 'secret-input', secret };
+        this.renderSecretInput(secret);
         this.terminalInput.render();
     }
     async handleSecretInput(input) {
@@ -4317,20 +4423,20 @@ export class InteractiveShell {
         }
         const trimmed = input.trim();
         if (!trimmed) {
-            display.showWarning('Enter a value or type cancel.');
-            this.terminalInput.render();
+            this.renderSecretInput(pending.secret, 'Enter a value or type cancel.');
             return;
         }
         if (trimmed.toLowerCase() === 'cancel') {
             this.pendingInteraction = null;
             this.pendingSecretRetry = null;
-            display.showInfo('Secret unchanged.');
+            this.clearInlineMenu();
+            this.updateStatusMessage('Secret unchanged.');
             this.terminalInput.render();
             return;
         }
         try {
             setSecretValue(pending.secret.id, trimmed);
-            display.showInfo(`${pending.secret.label} updated.`);
+            this.showInlineMenu('Secret updated', [`${pending.secret.label} saved.`], 'success');
             this.pendingInteraction = null;
             const deferred = this.pendingSecretRetry;
             this.pendingSecretRetry = null;
@@ -4345,7 +4451,7 @@ export class InteractiveShell {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            display.showError(message);
+            this.showInlineMenu('Secret error', [message], 'error');
             this.pendingInteraction = null;
             this.pendingSecretRetry = null;
         }
@@ -4364,6 +4470,7 @@ export class InteractiveShell {
         if (!agent) {
             return;
         }
+        this.logUserPrompt(request);
         this.isProcessing = true;
         this.uiUpdates.setMode('processing');
         this.terminalInput.setStreaming(true);
@@ -4383,7 +4490,8 @@ export class InteractiveShell {
         let responseText = '';
         try {
             // Start streaming - no header needed, the input area already provides context
-            this.startStreamingHeartbeat('Streaming response');
+            const heartbeatLabel = this.batchedOutputMode ? 'Processing response' : 'Streaming response';
+            this.startStreamingHeartbeat(heartbeatLabel);
             responseText = await agent.send(request, true);
             await this.awaitPendingCleanup();
             this.captureHistorySnapshot();
@@ -4499,7 +4607,8 @@ export class InteractiveShell {
         this.uiAdapter.startProcessing('Continuous execution mode');
         this.setProcessingStatus();
         // No streaming header - just start streaming directly
-        this.startStreamingHeartbeat('Streaming');
+        const continuousLabel = this.batchedOutputMode ? 'Processing' : 'Streaming';
+        this.startStreamingHeartbeat(continuousLabel);
         let iteration = 0;
         let lastResponse = '';
         let consecutiveNoProgress = 0;
@@ -4527,9 +4636,10 @@ When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
                 display.showSystemMessage(`\n📍 Iteration ${iteration}/${MAX_ITERATIONS}`);
                 this.updateStatusMessage(`Working on iteration ${iteration}...`);
                 try {
-                    // Send the request and capture the response (streaming disabled)
+                    // Send the request and capture the response as a single block
                     display.showThinking('Responding...');
                     this.refreshStatusLine(true);
+                    this.resetStreamBuffer();
                     const response = await agent.send(currentPrompt, true);
                     await this.awaitPendingCleanup();
                     this.captureHistorySnapshot();
@@ -5030,6 +5140,7 @@ What's the next action?`;
             // Send the error to the agent for fixing
             display.showThinking('Analyzing build errors');
             this.refreshStatusLine(true);
+            this.resetStreamBuffer();
             const response = await this.agent.send(prompt, true);
             display.stopThinking();
             this.refreshStatusLine(true);
@@ -5059,27 +5170,33 @@ What's the next action?`;
             };
             this.agent = this.runtimeSession.createAgent(selection, {
                 onStreamChunk: (chunk) => {
+                    if (this.batchedOutputMode) {
+                        this.captureStreamChunk(chunk);
+                        return;
+                    }
                     // Stream output using clean streamContent() - chat box floats below
                     this.terminalInput.streamContent(chunk);
                 },
                 onStreamFallback: (info) => this.handleStreamingFallback(info),
                 onAssistantMessage: (content, metadata) => {
                     const enriched = this.buildDisplayMetadata(metadata);
+                    const alreadyStreamedToUi = !this.batchedOutputMode && metadata.wasStreamed;
+                    const bufferedContent = this.consumeStreamBuffer(content);
                     // Update spinner based on message type
                     if (metadata.isFinal) {
                         // Skip display if content was already streamed to avoid double-display
-                        if (!metadata.wasStreamed) {
-                            const parsed = this.splitThinkingResponse(content);
+                        if (!alreadyStreamedToUi) {
+                            const parsed = this.splitThinkingResponse(bufferedContent);
                             if (parsed?.thinking) {
                                 const summary = this.extractThoughtSummary(parsed.thinking);
                                 if (summary) {
                                     display.updateThinking(`💭 ${summary}`);
                                 }
-                                display.showAssistantMessage(parsed.thinking, { ...enriched, isFinal: false });
+                                display.showThinkingBlock(parsed.thinking, enriched.elapsedMs ?? this.currentRunElapsedMs());
                             }
-                            const finalContent = parsed?.response?.trim() || content;
+                            const finalContent = parsed?.response?.trim() || bufferedContent.trim();
                             if (finalContent) {
-                                display.showAssistantMessage(finalContent, enriched);
+                                display.showAssistantMessage(finalContent, { ...enriched, isFinal: true });
                             }
                         }
                         // Status shown in mode controls bar - no separate status line needed
@@ -5101,8 +5218,13 @@ What's the next action?`;
                         // Stop spinner and show the narrative text directly
                         display.stopThinking();
                         // Skip display if content was already streamed to avoid double-display
-                        if (!metadata.wasStreamed) {
-                            display.showNarrative(content.trim());
+                        if (!alreadyStreamedToUi) {
+                            const parsed = this.splitThinkingResponse(bufferedContent);
+                            const thoughtContent = parsed?.thinking ?? parsed?.response ?? bufferedContent;
+                            const trimmed = thoughtContent.trim();
+                            if (trimmed) {
+                                display.showThinkingBlock(trimmed, enriched.elapsedMs ?? this.currentRunElapsedMs());
+                            }
                         }
                         // The isProcessing flag already shows "⏳ Processing..." - no need for duplicate status
                         this.requestPromptRefresh();
@@ -5304,15 +5426,17 @@ What's the next action?`;
         };
         // Always update context usage in the UI
         const percentUsed = Math.round(usageRatio * 100);
-        this.updateContextUsage(percentUsed);
+        this.updateContextUsage(percentUsed, CONTEXT_AUTOCOMPACT_PERCENT);
+        this.maybeShowContextWarning(percentUsed);
         this.refreshStatusLine(true);
-        if (usageRatio < CONTEXT_USAGE_THRESHOLD) {
+        if (!this.agent || this.cleanupInProgress || this.contextCompactionInFlight) {
             return null;
         }
-        if (!this.agent || this.cleanupInProgress) {
+        const trigger = this.shouldAutoCompactContext(usageRatio, windowTokens, total);
+        if (!trigger) {
             return null;
         }
-        return this.runContextCleanup(windowTokens, total);
+        return this.runContextCleanup(windowTokens, total, trigger);
     }
     totalTokens(usage) {
         if (!usage) {
@@ -5326,52 +5450,204 @@ What's the next action?`;
         const sum = input + output;
         return sum > 0 ? sum : null;
     }
-    async runContextCleanup(windowTokens, totalTokens) {
-        if (!this.agent) {
+    async runContextCleanup(windowTokens, totalTokens, trigger) {
+        const agent = this.agent;
+        if (!agent) {
+            return;
+        }
+        const contextManager = agent.getContextManager();
+        if (!contextManager) {
+            return;
+        }
+        const history = agent.getHistory();
+        if (history.length <= 1) {
             return;
         }
         this.cleanupInProgress = true;
+        this.contextCompactionInFlight = true;
         const cleanupStatusId = 'context-cleanup';
         let cleanupOverlayActive = false;
         try {
-            const history = this.agent.getHistory();
-            const { system, conversation } = this.partitionHistory(history);
-            if (!conversation.length) {
-                return;
-            }
-            const preserveCount = Math.min(conversation.length, CONTEXT_RECENT_MESSAGE_COUNT);
-            const preserved = conversation.slice(conversation.length - preserveCount);
-            const toSummarize = conversation.slice(0, conversation.length - preserveCount);
-            if (!toSummarize.length) {
-                return;
+            const percentUsed = Math.round((totalTokens / windowTokens) * 100);
+            const statusDetailParts = [`${percentUsed}% full`];
+            if (trigger?.reason) {
+                statusDetailParts.push(trigger.reason);
             }
-            cleanupOverlayActive = true;
             this.statusTracker.pushOverride(cleanupStatusId, 'Running context cleanup', {
-                detail: `Summarizing ${toSummarize.length} earlier messages`,
+                detail: statusDetailParts.join(' · '),
                 tone: 'warning',
             });
-            const percentUsed = Math.round((totalTokens / windowTokens) * 100);
-            // Update context usage in unified UI
-            this.updateContextUsage(percentUsed);
+            cleanupOverlayActive = true;
+            const triggerReason = trigger?.reason ?? 'Context optimization';
             display.showSystemMessage([
                 `Context usage: ${totalTokens.toLocaleString('en-US')} of ${windowTokens.toLocaleString('en-US')} tokens`,
-                `(${percentUsed}% full). Running automatic cleanup...`,
+                `(${percentUsed}% full). Auto-compacting${triggerReason ? `: ${triggerReason}` : '...'}`,
             ].join(' '));
-            const summary = await this.buildContextSummary(toSummarize);
-            if (!summary) {
-                throw new Error('Summary could not be generated.');
+            const beforeStats = contextManager.getStats(history);
+            const result = await contextManager.intelligentCompact(history);
+            const afterStats = contextManager.getStats(result.compacted);
+            const tokenSavings = Math.max(0, beforeStats.totalTokens - afterStats.totalTokens);
+            const percentSavings = beforeStats.totalTokens > 0 ? (tokenSavings / beforeStats.totalTokens) * 100 : 0;
+            const changed = this.historiesDiffer(history, result.compacted);
+            const meaningfulSavings = changed &&
+                (tokenSavings >= MIN_COMPACTION_TOKEN_SAVINGS || percentSavings >= MIN_COMPACTION_PERCENT_SAVINGS);
+            if (!meaningfulSavings) {
+                if (trigger?.forced || percentUsed >= 85) {
+                    display.showInfo('Auto-compaction completed but did not meaningfully reduce context size. Keeping existing history.');
+                }
+                return;
             }
-            const trimmed = this.buildTrimmedHistory(system, summary, preserved);
-            this.agent.loadHistory(trimmed);
-            display.showSystemMessage(`Context cleanup complete. Summarized ${toSummarize.length} earlier messages and preserved the latest ${preserved.length}.`);
+            agent.loadHistory(result.compacted);
+            this.cachedHistory = result.compacted;
+            const newPercentUsed = windowTokens > 0
+                ? Math.round((afterStats.totalTokens / windowTokens) * 100)
+                : afterStats.percentage;
+            this.latestTokenUsage = {
+                used: afterStats.totalTokens,
+                limit: windowTokens,
+            };
+            this.updateContextUsage(newPercentUsed, CONTEXT_AUTOCOMPACT_PERCENT);
+            this.lastContextWarningLevel = this.getContextWarningLevel(newPercentUsed);
+            this.refreshStatusLine(true);
+            const primarySignal = result.analysis.signals[0]?.reason ?? triggerReason;
+            display.showSystemMessage([
+                `Context compacted: ${beforeStats.percentage}% → ${afterStats.percentage}%`,
+                `(saved ~${tokenSavings.toLocaleString('en-US')} tokens).`,
+                primarySignal ? `Reason: ${primarySignal}.` : '',
+            ].filter(Boolean).join(' '));
+        }
+        catch (error) {
+            display.showError('Context compaction failed.', error);
         }
         finally {
             if (cleanupOverlayActive) {
                 this.statusTracker.clearOverride(cleanupStatusId);
             }
             this.cleanupInProgress = false;
+            this.contextCompactionInFlight = false;
         }
     }
+    shouldAutoCompactContext(usageRatio, windowTokens, totalTokens) {
+        const featureFlags = loadFeatureFlags();
+        if (featureFlags.autoCompact === false) {
+            return null;
+        }
+        const agent = this.agent;
+        if (!agent) {
+            return null;
+        }
+        const contextManager = agent.getContextManager();
+        if (!contextManager) {
+            return null;
+        }
+        const history = agent.getHistory();
+        if (history.length <= 1) {
+            return null;
+        }
+        const percentUsed = Math.round(usageRatio * 100);
+        const analysis = contextManager.shouldTriggerCompaction(history);
+        const overflowRisk = this.hasContextOverflowRisk(contextManager);
+        if (usageRatio >= CONTEXT_USAGE_THRESHOLD) {
+            return { reason: analysis.reason ?? `Context usage at ${percentUsed}%`, forced: true };
+        }
+        if (usageRatio >= CONTEXT_AUTOCOMPACT_FLOOR && (analysis.shouldCompact || overflowRisk)) {
+            const reason = analysis.reason
+                ?? (overflowRisk ? 'Heavy tool output detected' : 'Compaction signals detected');
+            return { reason, forced: false };
+        }
+        return null;
+    }
+    hasContextOverflowRisk(contextManager) {
+        if (!contextManager?.detectContextOverflowRisk) {
+            return false;
+        }
+        try {
+            const toolHistory = this.runtimeSession.toolRuntime.getToolHistory?.();
+            if (!toolHistory?.length) {
+                return false;
+            }
+            const serialized = toolHistory.map((entry) => {
+                const args = entry.args ?? {};
+                const argsText = Object.keys(args).length ? ` ${JSON.stringify(args)}` : '';
+                return `${entry.toolName}${argsText}`;
+            });
+            return contextManager.detectContextOverflowRisk(serialized);
+        }
+        catch {
+            return false;
+        }
+    }
+    getContextWarningLevel(percentage) {
+        if (percentage >= 90) {
+            return 'danger';
+        }
+        if (percentage >= 70) {
+            return 'warning';
+        }
+        if (percentage >= 50) {
+            return 'info';
+        }
+        return null;
+    }
+    maybeShowContextWarning(percentage) {
+        const level = this.getContextWarningLevel(percentage);
+        if (level === this.lastContextWarningLevel) {
+            if (level === null) {
+                this.lastContextWarningLevel = null;
+            }
+            return;
+        }
+        this.lastContextWarningLevel = level;
+        switch (level) {
+            case 'info':
+                display.showInfo('Context usage is climbing. Auto-compaction will engage if it keeps growing.');
+                break;
+            case 'warning':
+                display.showWarning('Context is getting full. Auto-compaction will try to preserve space.');
+                break;
+            case 'danger':
+                display.showWarning('Context is near capacity. Attempting automatic compaction.');
+                break;
+            default:
+                break;
+        }
+    }
+    historiesDiffer(original, compacted) {
+        if (original.length !== compacted.length) {
+            return true;
+        }
+        for (let i = 0; i < original.length; i++) {
+            const a = original[i];
+            const b = compacted[i];
+            if (a.role !== b.role) {
+                return true;
+            }
+            if ((a.content ?? '') !== (b.content ?? '')) {
+                return true;
+            }
+            const aName = 'name' in a ? a.name : undefined;
+            const bName = 'name' in b ? b.name : undefined;
+            if ((aName ?? '') !== (bName ?? '')) {
+                return true;
+            }
+            const aToolCallId = 'toolCallId' in a ? a.toolCallId : undefined;
+            const bToolCallId = 'toolCallId' in b ? b.toolCallId : undefined;
+            if ((aToolCallId ?? '') !== (bToolCallId ?? '')) {
+                return true;
+            }
+            const aTools = 'toolCalls' in a ? a.toolCalls ?? [] : [];
+            const bTools = 'toolCalls' in b ? b.toolCalls ?? [] : [];
+            if (aTools.length !== bTools.length) {
+                return true;
+            }
+            for (let j = 0; j < aTools.length; j++) {
+                if (JSON.stringify(aTools[j]) !== JSON.stringify(bTools[j])) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
     partitionHistory(history) {
         const system = [];
         const conversation = [];
@@ -5507,7 +5783,12 @@ What's the next action?`;
         const reason = info.reason ? ` (${info.reason.replace(/-/g, ' ')})` : '';
         const partialNote = info.partialResponse ? ' Received partial stream before failure.' : '';
         display.showWarning(`Streaming failed${reason}, retrying without streaming.${detail}${partialNote}`);
-        this.startStreamingHeartbeat('Fallback in progress');
+        const bufferedPartial = this.consumeStreamBuffer(info.partialResponse ?? '');
+        if (this.batchedOutputMode && bufferedPartial.trim()) {
+            display.showThinkingBlock(bufferedPartial.trim(), this.currentRunElapsedMs());
+        }
+        const fallbackLabel = this.batchedOutputMode ? 'Retrying (batched)' : 'Fallback in progress';
+        this.startStreamingHeartbeat(fallbackLabel);
         this.requestPromptRefresh(true);
     }
     handleProviderError(error, retryAction) {
@@ -5518,9 +5799,9 @@ What's the next action?`;
         this.handleApiKeyIssue(apiKeyIssue, retryAction);
         return true;
     }
-    handleApiKeyIssue(info, retryAction) {
+    handleApiKeyIssue(info, retryAction, contextLabel) {
         const secret = info.secret ?? null;
-        const providerLabel = info.provider ? this.providerLabel(info.provider) : 'the selected provider';
+        const providerLabel = contextLabel ?? (info.provider ? this.providerLabel(info.provider) : 'the selected provider');
         if (!secret) {
             this.pendingSecretRetry = null;
             const guidance = 'Run "/secrets" to configure the required API key or export it (e.g., EXPORT KEY=value) before launching the CLI.';
@@ -5542,6 +5823,10 @@ What's the next action?`;
         this.pendingInteraction = { type: 'secret-input', secret };
         this.showSecretGuidance(secret, isMissing);
     }
+    handleToolApiKeyIssue(info, call) {
+        const label = call?.name ? `${call.name} tool` : 'web tools';
+        this.handleApiKeyIssue(info, undefined, label);
+    }
     showSecretGuidance(secret, promptForInput) {
         const lines = [];
         if (promptForInput) {
@@ -5551,7 +5836,7 @@ What's the next action?`;
             lines.push(`Update the stored value for ${secret.label} or type "cancel".`);
         }
         lines.push(`Tip: run "/secrets" anytime to manage credentials or export ${secret.envVar}=<value> before launching the CLI.`);
-        display.showSystemMessage(lines.join('\n'));
+        this.showInlineMenu('Secrets', lines, promptForInput ? 'warning' : 'info');
     }
     colorizeDropdownLine(text, index) {
         if (!DROPDOWN_COLORS.length) {