erosolar-cli 1.0.2 → 1.0.3

package/dist/shell/interactiveShell.js

@@ -3,37 +3,15 @@ import { stdin as input, stdout as output, exit } from 'node:process';
 import { display } from '../ui/display.js';
 import { formatUserPrompt, theme } from '../ui/theme.js';
 import { getContextWindowTokens } from '../core/contextWindow.js';
-import { ensureSecretForProvider, getSecretValue, listSecretDefinitions, maskSecret, setSecretValue, } from '../core/secretStore.js';
+import { ensureSecretForProvider, getSecretDefinitionForProvider, getSecretValue, listSecretDefinitions, maskSecret, setSecretValue, } from '../core/secretStore.js';
 import { saveActiveProfilePreference, saveModelPreference, loadToolSettings, saveToolSettings, clearToolSettings, clearActiveProfilePreference, } from '../core/preferences.js';
-import { buildEnabledToolSet, getToolToggleOptions, } from '../capabilities/toolRegistry.js';
+import { buildEnabledToolSet, evaluateToolPermissions, getToolToggleOptions, } from '../capabilities/toolRegistry.js';
 import { BracketedPasteManager } from './bracketedPasteManager.js';
+import { PromptSkin } from './promptSkin.js';
 import { detectApiKeyError } from '../core/errors/apiKeyErrors.js';
-const COMMON_THOUGHT_LEVELS = [
-    {
-        id: 'direct',
-        label: 'Direct',
-        description: 'Fast edits with minimal narration or visible reasoning.',
-        instruction: 'Operate in direct mode: answer concisely, skip verbose reasoning, and surface only the minimum context needed before giving the final response.',
-        reasoningEffort: 'low',
-        textVerbosity: 'low',
-    },
-    {
-        id: 'balanced',
-        label: 'Balanced',
-        description: 'Blend short reasoning snippets with actionable guidance.',
-        instruction: 'Operate in balanced mode: share a couple of focused reasoning bullets before the final answer so the operator can follow along.',
-        reasoningEffort: 'medium',
-        textVerbosity: 'medium',
-    },
-    {
-        id: 'deep',
-        label: 'Deep',
-        description: 'Full investigative reasoning for gnarly bugs or planning.',
-        instruction: 'Operate in deep thinking mode: narrate a careful, multi-step reasoning path before finalizing, especially when analyzing complex code paths.',
-        reasoningEffort: 'high',
-        textVerbosity: 'high',
-    },
-];
+import { INTERRUPT_HINT } from './liveStatus.js';
+import { buildWorkspaceContext } from '../workspace.js';
+import { buildInteractiveSystemPrompt } from './systemPrompt.js';
 const DROPDOWN_COLORS = [
     theme.primary,
     theme.info,
@@ -48,31 +26,35 @@ const MODEL_PRESETS = [
         label: 'gpt-5.1-codex',
         provider: 'openai',
         description: 'Optimized for Erosolar Code with the latest coding weights from OpenAI.',
-        thoughtLevels: COMMON_THOUGHT_LEVELS,
+        reasoningEffort: 'medium',
     },
     {
         id: 'gpt-5.1',
         label: 'gpt-5.1',
         provider: 'openai',
         description: 'Balanced reasoning model when you need equal parts code and analysis.',
+        reasoningEffort: 'medium',
     },
     {
         id: 'gpt-5-pro',
         label: 'gpt-5-pro',
         provider: 'openai',
         description: 'OpenAI\'s flagship GPT-5 Pro for maximum depth and planning.',
+        reasoningEffort: 'medium',
     },
     {
         id: 'gpt-5-mini',
         label: 'gpt-5-mini',
         provider: 'openai',
         description: 'GPT-5 Mini with faster turnarounds while staying code-aware.',
+        reasoningEffort: 'medium',
     },
     {
         id: 'gpt-5-nano',
         label: 'gpt-5-nano',
         provider: 'openai',
         description: 'Ultra-responsive GPT-5 Nano tuned for edits and quick summaries.',
+        reasoningEffort: 'medium',
     },
     {
         id: 'claude-sonnet-4-5-20250929',
@@ -151,13 +133,15 @@ const BASE_SLASH_COMMANDS = [
     { command: '/model', description: 'Choose what model to use' },
     { command: '/secrets', description: 'Configure API keys' },
     { command: '/tools', description: 'Enable or disable CLI tools' },
+    { command: '/doctor', description: 'Check environment, secrets, and tool readiness' },
+    { command: '/checks', description: 'Run repo checks (npm test / npm run build / npm run lint)' },
+    { command: '/context', description: 'Refresh workspace snapshot (depth/excerpt overrides)' },
 ];
 const PROVIDER_LABELS = {
     openai: 'OpenAI',
     anthropic: 'Anthropic',
     deepseek: 'DeepSeek',
     xai: 'xAI',
-    tavily: 'Tavily',
     google: 'Google Gemini',
 };
 const MULTILINE_INPUT_FLUSH_DELAY_MS = 30;
@@ -180,8 +164,8 @@ export class InteractiveShell {
     profileLabel;
     workingDir;
     runtimeSession;
-    toolContext;
     baseSystemPrompt;
+    workspaceOptions;
     sessionState;
     isProcessing = false;
     pendingInteraction = null;
@@ -198,25 +182,30 @@ export class InteractiveShell {
     agentMenu;
     slashCommands;
     bannerSessionState = null;
+    promptSkin;
+    statusTracker;
+    statusSubscription = null;
+    activeContextWindowTokens = null;
+    promptSkinOutputDisposer = null;
     constructor(config) {
         this.profile = config.profile;
         this.profileLabel = config.profileLabel;
         this.workingDir = config.workingDir;
         this.runtimeSession = config.session;
-        this.toolContext = this.runtimeSession.toolContext;
         this.baseSystemPrompt = config.baseSystemPrompt;
+        this.workspaceOptions = { ...config.workspaceOptions };
         this.sessionState = {
             provider: config.initialModel.provider,
             model: config.initialModel.model,
             temperature: config.initialModel.temperature,
             maxTokens: config.initialModel.maxTokens,
-            thoughtLevel: this.resolveThoughtLevelOption(config.initialModel.model, config.initialModel.thoughtLevelId),
+            reasoningEffort: config.initialModel.reasoningEffort,
         };
+        this.applyPresetReasoningDefaults();
         // The welcome banner only includes model + provider on launch, so mark that as the initial state.
         this.bannerSessionState = {
             model: this.sessionState.model,
             provider: this.sessionState.provider,
-            thoughtLabel: undefined,
         };
         this.agentMenu = config.agentSelection ?? null;
         this.slashCommands = [...BASE_SLASH_COMMANDS];
@@ -226,12 +215,20 @@ export class InteractiveShell {
                 description: 'Select the default agent profile (applies on next launch)',
             });
         }
+        this.statusTracker = config.statusTracker;
         this.rl = readline.createInterface({
             input,
             output,
             prompt: formatUserPrompt(this.profileLabel || this.profile),
             terminal: true,
         });
+        this.promptSkin = new PromptSkin(this.rl);
+        this.promptSkinOutputDisposer = display.registerOutputInterceptor({
+            beforeWrite: () => this.promptSkin.beginOutput(),
+            afterWrite: () => this.promptSkin.endOutput(),
+        });
+        this.setupStatusTracking();
+        this.refreshContextGauge();
         this.bracketedPasteEnabled = this.enableBracketedPasteMode();
         this.bracketedPaste = new BracketedPasteManager(this.bracketedPasteEnabled);
         this.rebuildAgent();
@@ -241,7 +238,9 @@ export class InteractiveShell {
     async start(initialPrompt) {
         if (initialPrompt) {
             display.newLine();
+            this.promptSkin.beginOutput();
             console.log(`${formatUserPrompt(this.profileLabel || this.profile)}${initialPrompt}`);
+            this.promptSkin.endOutput();
             await this.processInputBlock(initialPrompt);
             return;
         }
@@ -386,8 +385,15 @@ export class InteractiveShell {
         });
         this.rl.on('close', () => {
             this.disableBracketedPasteMode();
+            this.teardownStatusTracking();
+            if (this.promptSkinOutputDisposer) {
+                this.promptSkinOutputDisposer();
+                this.promptSkinOutputDisposer = null;
+            }
+            this.promptSkin.dispose();
             display.newLine();
-            display.showInfo('Goodbye!');
+            const highlightedEmail = theme.info('support@ero.solar');
+            display.showInfo(`⚠️  WARNING: This is pre-alpha testing software. May contain bugs and potential dangers. Email ${highlightedEmail} for support.`);
             exit(0);
         });
         this.setupSlashCommandPreviewHandler();
@@ -402,6 +408,49 @@ export class InteractiveShell {
             this.handleSlashCommandPreviewChange();
         });
     }
+    setupStatusTracking() {
+        this.statusSubscription = this.statusTracker.subscribe((state) => {
+            this.promptSkin.setStatus(state);
+        });
+        this.setIdleStatus();
+    }
+    teardownStatusTracking() {
+        if (this.statusSubscription) {
+            this.statusSubscription();
+            this.statusSubscription = null;
+        }
+        this.statusTracker.reset();
+    }
+    setIdleStatus(detail) {
+        const details = this.buildStatusDetail(detail ?? this.describeModelDetail());
+        this.statusTracker.setBase('Ready for prompts', {
+            detail: details,
+            tone: 'success',
+        });
+    }
+    setProcessingStatus(detail) {
+        const details = this.buildStatusDetail(detail ?? this.describeModelDetail(), INTERRUPT_HINT);
+        this.statusTracker.setBase('Working on your request', {
+            detail: details,
+            tone: 'info',
+            animate: true,
+        });
+    }
+    describeModelDetail() {
+        const provider = this.providerLabel(this.sessionState.provider);
+        return `${provider} · ${this.sessionState.model}`;
+    }
+    buildStatusDetail(...segments) {
+        const normalized = segments
+            .map((segment) => (typeof segment === 'string' ? segment.trim() : ''))
+            .filter((segment) => Boolean(segment));
+        return normalized.length ? normalized : undefined;
+    }
+    refreshContextGauge() {
+        const tokens = getContextWindowTokens(this.sessionState.model);
+        this.activeContextWindowTokens =
+            typeof tokens === 'number' && Number.isFinite(tokens) ? tokens : null;
+    }
     handleSlashCommandPreviewChange() {
         if (this.pendingInteraction || this.awaitingPasteConfirmation) {
             this.slashPreviewVisible = false;
@@ -533,9 +582,6 @@ export class InteractiveShell {
             case 'model':
                 await this.handleModelSelection(input);
                 return true;
-            case 'thought-level':
-                await this.handleThoughtLevelSelection(input);
-                return true;
             case 'secret-select':
                 await this.handleSecretSelection(input);
                 return true;
@@ -564,6 +610,15 @@ export class InteractiveShell {
             case '/tools':
                 this.showToolsMenu();
                 break;
+            case '/doctor':
+                this.runDoctor();
+                break;
+            case '/checks':
+                await this.runRepoChecksCommand();
+                break;
+            case '/context':
+                await this.refreshWorkspaceContextCommand(input);
+                break;
             case '/agents':
                 this.showAgentsMenu();
                 break;
@@ -581,6 +636,143 @@ export class InteractiveShell {
         ];
         display.showSystemMessage(info.join('\n'));
     }
+    runDoctor() {
+        const lines = [];
+        lines.push(theme.bold('Environment diagnostics'));
+        lines.push('');
+        lines.push(`${theme.secondary('Workspace')}: ${this.workingDir}`);
+        lines.push('');
+        lines.push(theme.bold('Provider credentials'));
+        const providerDefinition = getSecretDefinitionForProvider(this.sessionState.provider);
+        if (providerDefinition) {
+            const currentValue = getSecretValue(providerDefinition.id);
+            if (currentValue) {
+                lines.push(`${theme.success('✓')} ${providerDefinition.label} configured (${providerDefinition.envVar}).`);
+            }
+            else {
+                lines.push(`${theme.warning('⚠')} Missing ${providerDefinition.label} (${providerDefinition.envVar}). Run /secrets to configure it.`);
+            }
+        }
+        else {
+            lines.push(`${theme.secondary('•')} ${this.providerLabel(this.sessionState.provider)} does not require an API key.`);
+        }
+        lines.push('');
+        lines.push(theme.bold('Tool suites'));
+        const toolSettings = loadToolSettings();
+        const selection = buildEnabledToolSet(toolSettings);
+        const permissions = evaluateToolPermissions(selection);
+        const options = getToolToggleOptions();
+        const enabledLabels = options
+            .filter((option) => selection.has(option.id))
+            .map((option) => option.label);
+        lines.push(`Enabled: ${enabledLabels.length ? enabledLabels.join(', ') : 'none'}`);
+        if (!permissions.warnings.length) {
+            lines.push(theme.success('All enabled suites loaded successfully.'));
+        }
+        else {
+            lines.push(theme.warning('Issues detected:'));
+            for (const warning of permissions.warnings) {
+                const detail = this.describeToolWarning(warning);
+                lines.push(`  - ${detail}`);
+            }
+        }
+        display.showSystemMessage(lines.join('\n'));
+    }
+    async runRepoChecksCommand() {
+        if (this.isProcessing) {
+            display.showWarning('Wait for the active response to finish before running checks.');
+            return;
+        }
+        const call = {
+            id: 'manual-run-repo-checks',
+            name: 'run_repo_checks',
+            arguments: {},
+        };
+        display.showInfo('Running repo checks (npm test/build/lint when available)...');
+        const output = await this.runtimeSession.toolRuntime.execute(call);
+        display.showSystemMessage(output);
+    }
+    async refreshWorkspaceContextCommand(input) {
+        if (this.isProcessing) {
+            display.showWarning('Wait for the active response to finish before refreshing the snapshot.');
+            return;
+        }
+        const { overrides, error } = this.parseContextOverrideTokens(input);
+        if (error) {
+            display.showWarning(`${error} ${this.describeContextOverrideUsage()}`);
+            return;
+        }
+        if (overrides) {
+            this.workspaceOptions = { ...this.workspaceOptions, ...overrides };
+        }
+        display.showInfo('Refreshing workspace snapshot...');
+        const context = buildWorkspaceContext(this.workingDir, this.workspaceOptions);
+        const profileConfig = this.runtimeSession.refreshWorkspaceContext(context);
+        const tools = this.runtimeSession.toolRuntime.listProviderTools();
+        this.baseSystemPrompt = buildInteractiveSystemPrompt(profileConfig.systemPrompt, profileConfig.label, tools);
+        if (this.rebuildAgent()) {
+            display.showInfo(`Workspace snapshot refreshed (${this.describeWorkspaceOptions()}).`);
+        }
+        else {
+            display.showWarning('Workspace snapshot refreshed, but the agent failed to rebuild. Run /doctor for details.');
+        }
+    }
+    parseContextOverrideTokens(input) {
+        const overrides = {};
+        let hasOverride = false;
+        const tokens = input
+            .trim()
+            .split(/\s+/)
+            .slice(1);
+        for (const token of tokens) {
+            if (!token) {
+                continue;
+            }
+            const [rawKey, rawValue] = token.split('=');
+            if (!rawKey || !rawValue) {
+                return { overrides: null, error: `Invalid option "${token}".` };
+            }
+            const key = rawKey.toLowerCase();
+            const value = Number.parseInt(rawValue, 10);
+            if (!Number.isFinite(value) || value <= 0) {
+                return { overrides: null, error: `Value for "${key}" must be a positive integer.` };
+            }
+            switch (key) {
+                case 'depth':
+                    overrides.treeDepth = value;
+                    hasOverride = true;
+                    break;
+                case 'entries':
+                    overrides.maxEntries = value;
+                    hasOverride = true;
+                    break;
+                case 'excerpt':
+                case 'doc':
+                case 'docs':
+                    overrides.docExcerptLimit = value;
+                    hasOverride = true;
+                    break;
+                default:
+                    return { overrides: null, error: `Unknown option "${key}".` };
+            }
+        }
+        return { overrides: hasOverride ? overrides : null };
+    }
+    describeWorkspaceOptions() {
+        const depth = this.workspaceOptions.treeDepth ?? 'default';
+        const entries = this.workspaceOptions.maxEntries ?? 'default';
+        const excerpt = this.workspaceOptions.docExcerptLimit ?? 'default';
+        return `depth=${depth}, entries=${entries}, excerpt=${excerpt}`;
+    }
+    describeContextOverrideUsage() {
+        return 'Usage: /context [depth=<n>] [entries=<n>] [excerpt=<n>]';
+    }
+    describeToolWarning(warning) {
+        if (warning.reason === 'missing-secret' && warning.secretId) {
+            return `${warning.label}: missing ${warning.secretId}. Use /secrets to configure it.`;
+        }
+        return `${warning.label}: ${warning.reason}.`;
+    }
     buildSlashCommandList(header) {
         const lines = [theme.gradient.primary(header), ''];
         for (const command of this.slashCommands) {
@@ -649,34 +841,6 @@ export class InteractiveShell {
         display.showSystemMessage(lines.join('\n'));
         this.pendingInteraction = { type: 'model', provider: option.provider, options: models };
     }
-    showThoughtLevelMenu(preset) {
-        const options = preset.thoughtLevels ?? [];
-        if (!options.length) {
-            return;
-        }
-        const lines = [
-            theme.bold(`Select a thought level for ${preset.label}:`),
-            ...options.map((option, index) => {
-                const isCurrent = this.sessionState.model === preset.id && this.sessionState.thoughtLevel?.id === option.id;
-                const label = this.colorizeDropdownLine(`${index + 1}. ${option.label}`, index);
-                const suffix = isCurrent ? ` ${theme.primary('• current')}` : '';
-                const description = this.colorizeDropdownLine(`   ${option.description}`, index);
-                return `${label}${suffix}\n${description}`;
-            }),
-            'Type the number of the thought level to use it, type "back" to pick another model, or type "cancel".',
-        ];
-        display.showSystemMessage(lines.join('\n'));
-        this.pendingInteraction = { type: 'thought-level', preset, options };
-    }
-    showModelsForProvider(providerId) {
-        const providerOptions = this.buildProviderOptions();
-        const target = providerOptions.find((entry) => entry.provider === providerId);
-        if (target) {
-            this.showProviderModels(target);
-            return;
-        }
-        this.showModelMenu();
-    }
     showSecretsMenu() {
         const definitions = listSecretDefinitions();
         const lines = [
@@ -836,77 +1000,27 @@ export class InteractiveShell {
             return;
         }
         this.pendingInteraction = null;
-        if (preset.thoughtLevels && preset.thoughtLevels.length > 0) {
-            this.showThoughtLevelMenu(preset);
-            this.rl.prompt();
-            return;
-        }
         await this.applyModelPreset(preset);
         this.rl.prompt();
     }
-    async handleThoughtLevelSelection(input) {
-        const pending = this.pendingInteraction;
-        if (!pending || pending.type !== 'thought-level') {
-            return;
-        }
-        const trimmed = input.trim();
-        if (!trimmed) {
-            display.showWarning('Enter a number, type "back", or type "cancel".');
-            this.rl.prompt();
-            return;
-        }
-        const normalized = trimmed.toLowerCase();
-        if (normalized === 'back') {
-            this.pendingInteraction = null;
-            this.showModelsForProvider(pending.preset.provider);
-            this.rl.prompt();
-            return;
-        }
-        if (normalized === 'cancel') {
-            this.pendingInteraction = null;
-            display.showInfo('Thought level selection cancelled.');
-            this.rl.prompt();
-            return;
-        }
-        const choice = Number.parseInt(trimmed, 10);
-        if (!Number.isFinite(choice)) {
-            display.showWarning('Please enter a valid number.');
-            this.rl.prompt();
-            return;
-        }
-        const option = pending.options[choice - 1];
-        if (!option) {
-            display.showWarning('That option is not available.');
-            this.rl.prompt();
-            return;
-        }
-        this.pendingInteraction = null;
-        await this.applyModelPreset(pending.preset, option);
-        this.rl.prompt();
-    }
-    async applyModelPreset(preset, thoughtLevel) {
+    async applyModelPreset(preset) {
         try {
             ensureSecretForProvider(preset.provider);
         }
         catch (error) {
-            this.handleAgentSetupError(error, () => this.applyModelPreset(preset, thoughtLevel), preset.provider);
+            this.handleAgentSetupError(error, () => this.applyModelPreset(preset), preset.provider);
             return;
         }
-        const existingThoughtLevelId = this.sessionState.thoughtLevel?.id;
-        const resolvedThoughtLevel = thoughtLevel ??
-            (preset.thoughtLevels?.length && existingThoughtLevelId
-                ? preset.thoughtLevels.find((option) => option.id === existingThoughtLevelId)
-                : undefined);
         this.sessionState = {
             provider: preset.provider,
             model: preset.id,
             temperature: preset.temperature,
             maxTokens: preset.maxTokens,
-            thoughtLevel: resolvedThoughtLevel,
+            reasoningEffort: preset.reasoningEffort,
         };
+        this.applyPresetReasoningDefaults();
         if (this.rebuildAgent()) {
-            const suffix = resolvedThoughtLevel ? ` (${resolvedThoughtLevel.label} thought level)` : '';
-            display.showInfo(`Switched to ${preset.label}${suffix}.`);
+            display.showInfo(`Switched to ${preset.label}.`);
             this.refreshBannerSessionInfo();
             this.persistSessionPreference();
         }
@@ -997,6 +1111,7 @@ export class InteractiveShell {
             return;
         }
         this.isProcessing = true;
+        this.setProcessingStatus();
         try {
             display.newLine();
             await agent.send(request);
@@ -1010,6 +1125,7 @@ export class InteractiveShell {
         }
         finally {
             this.isProcessing = false;
+            this.setIdleStatus();
             display.newLine();
         }
     }
@@ -1037,10 +1153,8 @@ export class InteractiveShell {
                 model: this.sessionState.model,
                 temperature: this.sessionState.temperature,
                 maxTokens: this.sessionState.maxTokens,
-                thoughtLevelId: this.sessionState.thoughtLevel?.id,
-                reasoningEffort: this.sessionState.thoughtLevel?.reasoningEffort,
-                textVerbosity: this.sessionState.thoughtLevel?.textVerbosity,
                 systemPrompt: this.buildSystemPrompt(),
+                reasoningEffort: this.sessionState.reasoningEffort,
             };
             this.agent = this.runtimeSession.createAgent(selection, {
                 onAssistantMessage: (content, metadata) => {
@@ -1076,20 +1190,13 @@ export class InteractiveShell {
         if (typeof this.sessionState.maxTokens === 'number') {
             lines.push(`- Max tokens: ${this.sessionState.maxTokens}`);
         }
-        if (this.sessionState.thoughtLevel) {
-            lines.push(`- Thought level: ${this.sessionState.thoughtLevel.label}`);
-        }
         lines.push('', 'Use these values when describing your identity or answering model/provider questions. If anything feels stale, call the `profile_details` tool before responding.');
-        if (this.sessionState.thoughtLevel) {
-            lines.push('', `THOUGHT LEVEL DIRECTIVE (${this.sessionState.thoughtLevel.label.toUpperCase()}):`, this.sessionState.thoughtLevel.instruction);
-        }
         return lines.join('\n').trim();
     }
     buildDisplayMetadata(metadata) {
-        const contextWindowTokens = getContextWindowTokens(this.sessionState.model);
         return {
             ...metadata,
-            contextWindowTokens,
+            contextWindowTokens: this.activeContextWindowTokens,
         };
     }
     handleContextTelemetry(metadata, displayMetadata) {
@@ -1130,6 +1237,8 @@ export class InteractiveShell {
             return;
         }
         this.cleanupInProgress = true;
+        const cleanupStatusId = 'context-cleanup';
+        let cleanupOverlayActive = false;
         try {
             const history = this.agent.getHistory();
             const { system, conversation } = this.partitionHistory(history);
@@ -1142,6 +1251,12 @@ export class InteractiveShell {
             if (!toSummarize.length) {
                 return;
             }
+            cleanupOverlayActive = true;
+            this.statusTracker.pushOverride(cleanupStatusId, 'Running context cleanup', {
+                detail: this.buildStatusDetail(`Summarizing ${toSummarize.length} earlier messages`, INTERRUPT_HINT),
+                tone: 'warning',
+                animate: true,
+            });
             const percentUsed = Math.round((totalTokens / windowTokens) * 100);
             display.showSystemMessage([
                 `Context usage: ${totalTokens.toLocaleString('en-US')} of ${windowTokens.toLocaleString('en-US')} tokens`,
@@ -1156,6 +1271,9 @@ export class InteractiveShell {
             display.showSystemMessage(`Context cleanup complete. Summarized ${toSummarize.length} earlier messages and preserved the latest ${preserved.length}.`);
         }
         finally {
+            if (cleanupOverlayActive) {
+                this.statusTracker.clearOverride(cleanupStatusId);
+            }
             this.cleanupInProgress = false;
         }
     }
@@ -1341,30 +1459,29 @@ export class InteractiveShell {
     findModelPreset(modelId) {
         return MODEL_PRESETS.find((preset) => preset.id === modelId);
     }
-    resolveThoughtLevelOption(modelId, thoughtLevelId) {
-        if (!thoughtLevelId) {
-            return undefined;
+    applyPresetReasoningDefaults() {
+        if (this.sessionState.reasoningEffort) {
+            return;
         }
-        const preset = this.findModelPreset(modelId);
-        if (!preset?.thoughtLevels?.length) {
-            return undefined;
+        const preset = this.findModelPreset(this.sessionState.model);
+        if (preset?.reasoningEffort) {
+            this.sessionState.reasoningEffort = preset.reasoningEffort;
         }
-        return preset.thoughtLevels.find((option) => option.id === thoughtLevelId);
     }
     refreshBannerSessionInfo() {
         const nextState = {
             model: this.sessionState.model,
             provider: this.sessionState.provider,
-            thoughtLabel: this.sessionState.thoughtLevel?.label,
         };
         const previous = this.bannerSessionState;
-        if (previous &&
-            previous.model === nextState.model &&
-            previous.provider === nextState.provider &&
-            previous.thoughtLabel === nextState.thoughtLabel) {
+        if (previous && previous.model === nextState.model && previous.provider === nextState.provider) {
             return;
         }
-        display.updateSessionInfo(nextState.model, nextState.provider, nextState.thoughtLabel);
+        this.refreshContextGauge();
+        display.updateSessionInfo(nextState.model, nextState.provider);
+        if (!this.isProcessing) {
+            this.setIdleStatus();
+        }
         this.bannerSessionState = nextState;
     }
     providerLabel(id) {
@@ -1383,7 +1500,7 @@ export class InteractiveShell {
             model: this.sessionState.model,
             temperature: this.sessionState.temperature,
             maxTokens: this.sessionState.maxTokens,
-            thoughtLevelId: this.sessionState.thoughtLevel?.id,
+            reasoningEffort: this.sessionState.reasoningEffort,
         });
     }
     enableBracketedPasteMode() {
@@ -1424,3 +1541,4 @@ function setsEqual(first, second) {
     }
     return true;
 }
+//# sourceMappingURL=interactiveShell.js.map