erosolar-cli 1.0.2 → 1.0.5

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 { buildWorkspaceContext } from '../workspace.js';
+import { buildInteractiveSystemPrompt } from './systemPrompt.js';
+import { getModels, getSlashCommands, getProviders } from '../core/agentSchemaLoader.js';
 const DROPDOWN_COLORS = [
     theme.primary,
     theme.info,
@@ -42,124 +20,23 @@ const DROPDOWN_COLORS = [
     theme.success,
     theme.warning,
 ];
-const MODEL_PRESETS = [
-    {
-        id: 'gpt-5.1-codex',
-        label: 'gpt-5.1-codex',
-        provider: 'openai',
-        description: 'Optimized for Erosolar Code with the latest coding weights from OpenAI.',
-        thoughtLevels: COMMON_THOUGHT_LEVELS,
-    },
-    {
-        id: 'gpt-5.1',
-        label: 'gpt-5.1',
-        provider: 'openai',
-        description: 'Balanced reasoning model when you need equal parts code and analysis.',
-    },
-    {
-        id: 'gpt-5-pro',
-        label: 'gpt-5-pro',
-        provider: 'openai',
-        description: 'OpenAI\'s flagship GPT-5 Pro for maximum depth and planning.',
-    },
-    {
-        id: 'gpt-5-mini',
-        label: 'gpt-5-mini',
-        provider: 'openai',
-        description: 'GPT-5 Mini with faster turnarounds while staying code-aware.',
-    },
-    {
-        id: 'gpt-5-nano',
-        label: 'gpt-5-nano',
-        provider: 'openai',
-        description: 'Ultra-responsive GPT-5 Nano tuned for edits and quick summaries.',
-    },
-    {
-        id: 'claude-sonnet-4-5-20250929',
-        label: 'sonnet-4.5',
-        provider: 'anthropic',
-        description: 'Anthropic Sonnet 4.5 tuned for deeper planning across large repositories.',
-        temperature: 0.7,
-        maxTokens: 4096,
-    },
-    {
-        id: 'claude-opus-4.1',
-        label: 'opus-4.1',
-        provider: 'anthropic',
-        description: 'Anthropic Opus 4.1 for the richest Claude reasoning runs.',
-        temperature: 0.7,
-        maxTokens: 4096,
-    },
-    {
-        id: 'claude-haiku-4.5',
-        label: 'haiku-4.5',
-        provider: 'anthropic',
-        description: 'Anthropic Haiku 4.5 focused on latency-sensitive workflows.',
-        temperature: 0.5,
-        maxTokens: 4096,
-    },
-    {
-        id: 'deepseek-reasoner',
-        label: 'deepseek-reasoner',
-        provider: 'deepseek',
-        description: 'DeepSeek Reasoner for chain-of-thought exploration with tool depth.',
-    },
-    {
-        id: 'deepseek-chat',
-        label: 'deepseek-chat',
-        provider: 'deepseek',
-        description: 'DeepSeek Chat for faster interactive editing and summarization.',
-    },
-    {
-        id: 'grok-4',
-        label: 'grok-4',
-        provider: 'xai',
-        description: 'xAI Grok-4 for their highest quality coding and reasoning responses.',
-    },
-    {
-        id: 'grok-4-fast-reasoning',
-        label: 'grok-4-fast-reasoning',
-        provider: 'xai',
-        description: 'Grok-4 fast reasoning mode when you need lower latency with thinking enabled.',
-    },
-    {
-        id: 'grok-4-fast-non-reasoning',
-        label: 'grok-4-fast-non-reasoning',
-        provider: 'xai',
-        description: 'Grok-4 fast non reasoning variant for concise edits and summaries.',
-    },
-    {
-        id: 'grok-code-fast-1',
-        label: 'grok-code-fast-1',
-        provider: 'xai',
-        description: 'xAI Grok Code Fast 1 tuned specifically for rapid coding assistance.',
-    },
-    {
-        id: 'gemini-2.5-pro',
-        label: 'gemini-2.5-pro',
-        provider: 'google',
-        description: 'Google Gemini 2.5 Pro for multimodal deep reasoning with longer outputs.',
-    },
-    {
-        id: 'gemini-2.5-flash',
-        label: 'gemini-2.5-flash',
-        provider: 'google',
-        description: 'Google Gemini 2.5 Flash for lower-latency edits and iterative coding.',
-    },
-];
-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' },
-];
-const PROVIDER_LABELS = {
-    openai: 'OpenAI',
-    anthropic: 'Anthropic',
-    deepseek: 'DeepSeek',
-    xai: 'xAI',
-    tavily: 'Tavily',
-    google: 'Google Gemini',
-};
+// Load MODEL_PRESETS from centralized schema
+const MODEL_PRESETS = getModels().map((model) => ({
+    id: model.id,
+    label: model.label,
+    provider: model.provider,
+    description: model.description ?? '',
+    reasoningEffort: model.reasoningEffort,
+    temperature: model.temperature,
+    maxTokens: model.maxTokens,
+}));
+// Load BASE_SLASH_COMMANDS from centralized schema
+const BASE_SLASH_COMMANDS = getSlashCommands().map((cmd) => ({
+    command: cmd.command,
+    description: cmd.description,
+}));
+// Load PROVIDER_LABELS from centralized schema
+const PROVIDER_LABELS = Object.fromEntries(getProviders().map((provider) => [provider.id, provider.label]));
 const MULTILINE_INPUT_FLUSH_DELAY_MS = 30;
 const BRACKETED_PASTE_ENABLE = '\u001b[?2004h';
 const BRACKETED_PASTE_DISABLE = '\u001b[?2004l';
@@ -180,8 +57,8 @@ export class InteractiveShell {
     profileLabel;
     workingDir;
     runtimeSession;
-    toolContext;
     baseSystemPrompt;
+    workspaceOptions;
     sessionState;
     isProcessing = false;
     pendingInteraction = null;
@@ -198,25 +75,31 @@ export class InteractiveShell {
     agentMenu;
     slashCommands;
     bannerSessionState = null;
+    promptSkin;
+    statusTracker;
+    uiAdapter;
+    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 +109,22 @@ export class InteractiveShell {
                 description: 'Select the default agent profile (applies on next launch)',
             });
         }
+        this.statusTracker = config.statusTracker;
+        this.uiAdapter = config.uiAdapter;
         this.rl = readline.createInterface({
             input,
             output,
             prompt: formatUserPrompt(this.profileLabel || this.profile),
             terminal: true,
         });
+        this.promptSkin = new PromptSkin(this.rl);
+        // Keep legacy components for backward compatibility during transition
+        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 +134,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 +281,25 @@ export class InteractiveShell {
         });
         this.rl.on('close', () => {
             this.disableBracketedPasteMode();
+            this.teardownStatusTracking();
+            if (this.promptSkinOutputDisposer) {
+                this.promptSkinOutputDisposer();
+                this.promptSkinOutputDisposer = null;
+            }
+            this.promptSkin.dispose();
+            // Dispose unified UI adapter
+            this.uiAdapter.dispose();
             display.newLine();
-            display.showInfo('Goodbye!');
+            const highlightedEmail = theme.info('support@ero.solar');
+            const infoMessage = [
+                'Made available for defensive and offensive security operations.',
+                '',
+                'Learn more:',
+                'https://www.anthropic.com/news/disrupting-AI-espionage',
+                '',
+                `Email ${highlightedEmail} with any bugs or feedback`,
+            ].join('\n');
+            display.showInfo(infoMessage);
             exit(0);
         });
         this.setupSlashCommandPreviewHandler();
@@ -402,6 +314,40 @@ 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) {
+        this.statusTracker.setBase('Ready for prompts', {
+            detail: detail ?? this.describeModelDetail(),
+            tone: 'success',
+        });
+    }
+    setProcessingStatus(detail) {
+        this.statusTracker.setBase('Working on your request', {
+            detail: detail ?? this.describeModelDetail(),
+            tone: 'info',
+        });
+    }
+    describeModelDetail() {
+        const provider = this.providerLabel(this.sessionState.provider);
+        return `${provider} · ${this.sessionState.model}`;
+    }
+    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;
@@ -415,6 +361,7 @@ export class InteractiveShell {
         }
         if (!shouldShow && this.slashPreviewVisible) {
             this.slashPreviewVisible = false;
+            this.uiAdapter.hideSlashCommandPreview();
         }
     }
     shouldShowSlashCommandPreview() {
@@ -428,6 +375,9 @@ export class InteractiveShell {
     showSlashCommandPreview() {
         const preview = this.buildSlashCommandList('Slash Commands:');
         display.showSystemMessage(preview);
+        // Also show in the unified UI
+        const commands = this.slashCommands.map(cmd => cmd.command);
+        this.uiAdapter.showSlashCommandPreview(commands);
         this.rl.prompt(true);
     }
     enqueueUserInput(line, flushImmediately = false) {
@@ -466,6 +416,7 @@ export class InteractiveShell {
     }
     async processInputBlock(line, wasRapidMultiLine = false) {
         this.slashPreviewVisible = false;
+        this.uiAdapter.hideSlashCommandPreview();
         const trimmed = line.trim();
         if (await this.handlePendingInteraction(trimmed)) {
             return;
@@ -533,9 +484,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 +512,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 +538,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 +743,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 +902,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,8 +1013,12 @@ export class InteractiveShell {
             return;
         }
         this.isProcessing = true;
+        this.promptSkin.setOverlayVisible(false);
+        this.uiAdapter.startProcessing('Working on your request');
+        this.setProcessingStatus();
         try {
             display.newLine();
+            display.showThinking('Working on your request...');
             await agent.send(request);
             await this.awaitPendingCleanup();
         }
@@ -1009,7 +1029,11 @@ export class InteractiveShell {
             }
         }
         finally {
+            display.stopThinking();
             this.isProcessing = false;
+            this.promptSkin.setOverlayVisible(true);
+            this.uiAdapter.endProcessing('Ready for prompts');
+            this.setIdleStatus();
             display.newLine();
         }
     }
@@ -1037,14 +1061,24 @@ 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) => {
                     const enriched = this.buildDisplayMetadata(metadata);
+                    // Update spinner based on message type
+                    if (metadata.isFinal) {
+                        // Final response - update spinner before showing message
+                        display.updateThinking('Formulating response...');
+                    }
+                    else {
+                        // Thought/reasoning - extract key insight for spinner
+                        const thoughtSummary = this.extractThoughtSummary(content);
+                        if (thoughtSummary) {
+                            display.updateThinking(`💭 ${thoughtSummary}`);
+                        }
+                    }
                     display.showAssistantMessage(content, enriched);
                     const cleanup = this.handleContextTelemetry(metadata, enriched);
                     if (cleanup) {
@@ -1076,20 +1110,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) {
@@ -1105,6 +1132,9 @@ export class InteractiveShell {
             return null;
         }
         const usageRatio = total / windowTokens;
+        // Always update context usage in the UI
+        const percentUsed = Math.round(usageRatio * 100);
+        this.uiAdapter.updateContextUsage(percentUsed);
         if (usageRatio < CONTEXT_USAGE_THRESHOLD) {
             return null;
         }
@@ -1130,6 +1160,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,7 +1174,14 @@ export class InteractiveShell {
             if (!toSummarize.length) {
                 return;
             }
+            cleanupOverlayActive = true;
+            this.statusTracker.pushOverride(cleanupStatusId, 'Running context cleanup', {
+                detail: `Summarizing ${toSummarize.length} earlier messages`,
+                tone: 'warning',
+            });
             const percentUsed = Math.round((totalTokens / windowTokens) * 100);
+            // Update context usage in unified UI
+            this.uiAdapter.updateContextUsage(percentUsed);
             display.showSystemMessage([
                 `Context usage: ${totalTokens.toLocaleString('en-US')} of ${windowTokens.toLocaleString('en-US')} tokens`,
                 `(${percentUsed}% full). Running automatic cleanup...`,
@@ -1156,6 +1195,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 +1383,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) {
@@ -1377,13 +1418,34 @@ export class InteractiveShell {
         const entry = this.agentMenu.options.find((option) => option.name === name);
         return entry?.label ?? name;
     }
+    extractThoughtSummary(thought) {
+        // Extract first non-empty line
+        const lines = thought?.split('\n').filter(line => line.trim()) ?? [];
+        if (!lines.length) {
+            return null;
+        }
+        // Remove common thought prefixes
+        const cleaned = lines[0]
+            .trim()
+            .replace(/^(Thinking|Analyzing|Considering|Looking at|Let me)[:.\s]+/i, '')
+            .replace(/^I (should|need to|will|am)[:.\s]+/i, '')
+            .trim();
+        if (!cleaned) {
+            return null;
+        }
+        // Truncate to reasonable length
+        const maxLength = 50;
+        return cleaned.length > maxLength
+            ? cleaned.slice(0, maxLength - 3) + '...'
+            : cleaned;
+    }
     persistSessionPreference() {
         saveModelPreference(this.profile, {
             provider: this.sessionState.provider,
             model: this.sessionState.model,
             temperature: this.sessionState.temperature,
             maxTokens: this.sessionState.maxTokens,
-            thoughtLevelId: this.sessionState.thoughtLevel?.id,
+            reasoningEffort: this.sessionState.reasoningEffort,
         });
     }
     enableBracketedPasteMode() {
@@ -1424,3 +1486,4 @@ function setsEqual(first, second) {
     }
     return true;
 }
+//# sourceMappingURL=interactiveShell.js.map