@trenchwork/erosolar 1.1.40

package/dist/headless/interactiveShell.js

@@ -0,0 +1,2052 @@
+/**
+ * Interactive Shell - Full interactive CLI experience with rich UI.
+ *
+ * Usage:
+ *   agi                    # Start interactive shell
+ *   agi "initial prompt"   # Start with initial prompt
+ *
+ * Features:
+ * - Rich terminal UI with status bar
+ * - Command history
+ * - Streaming responses
+ * - Tool execution display
+ * - Ctrl+C to interrupt
+ */
+import { stdin, stdout, exit } from 'node:process';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { exec as childExec } from 'node:child_process';
+import { promisify } from 'node:util';
+import chalk from 'chalk';
+import { getHITL, hitlEvents } from '../core/hitl.js';
+// Connector imports removed — CLI is local-only, no GitHub gate.
+// Stub functions (antiTermination removed)
+const initializeProtection = (_config) => { };
+const enterCriticalSection = (_name) => { };
+const exitCriticalSection = (_name) => { };
+// Import real shutdown handler for reliable Ctrl+C handling
+import { authorizedShutdown, installSignalHandlers, onShutdown } from '../core/shutdown.js';
+import { resolveProfileConfig } from '../config.js';
+import { createAgentController } from '../runtime/agentController.js';
+import { resolveWorkspaceCaptureOptions, buildWorkspaceContext } from '../workspace.js';
+import { loadAllSecrets, listSecretDefinitions, setSecretValue, getSecretValue } from '../core/secretStore.js';
+import { getConfiguredProviders, getProvidersStatus, quickCheckProviders, getCachedDiscoveredModels, sortModelsByPriority } from '../core/modelDiscovery.js';
+import { saveModelPreference, loadFeatureFlags, toggleFeatureFlag } from '../core/preferences.js';
+import { setDebugMode, debugSnippet } from '../utils/debugLogger.js';
+const exec = promisify(childExec);
+import { ensureNextSteps } from '../core/finalResponseFormatter.js';
+import { getTaskCompletionDetector, detectFailingTestOrBuild } from '../core/taskCompletionDetector.js';
+import { checkForUpdates, performBackgroundUpdate } from '../core/updateChecker.js';
+import { startNewRun } from '../tools/fileChangeTracker.js';
+import { onSudoPasswordNeeded, offSudoPasswordNeeded, provideSudoPassword } from '../core/sudoPasswordManager.js';
+import { reportStatus, setStatusSink } from '../utils/statusReporter.js';
+import { isSafetyRefusal } from '../core/refusalDetection.js';
+// Timeout constants for regular prompt processing (reasoning models like DeepSeek)
+const PROMPT_REASONING_TIMEOUT_MS = 60 * 1000; // 60 seconds max for reasoning-only without action
+// Per-step timeout: how long we'll wait for the *next* event before
+// declaring the stream stuck and bailing out. Set generously (10 min) so
+// long-running tool calls (a build, a slow `npm install`, etc.) don't
+// trip it, but short enough that a dead provider / network drop doesn't
+// leave the user staring at a forever-spinner with Ctrl+C as their only
+// escape. iterateWithTimeout resets this per-event, so it only fires on
+// genuine inactivity. Override with EROSOLAR_STEP_TIMEOUT_MS for tests.
+const PROMPT_STEP_TIMEOUT_MS = (() => {
+    const env = process.env['EROSOLAR_STEP_TIMEOUT_MS'];
+    const parsed = env ? Number(env) : NaN;
+    if (Number.isFinite(parsed) && parsed > 0)
+        return parsed;
+    return 10 * 60 * 1000;
+})();
+const HITL_TOOL_PREFIX = 'HITL_';
+const isHitlToolName = (toolName) => toolName.startsWith(HITL_TOOL_PREFIX);
+/**
+ * Iterate over an async iterator with a timeout per iteration.
+ * If no event is received within the timeout, yields a special timeout marker.
+ * Emits timeout markers without aborting the underlying iterator.
+ * Pass Infinity to disable timeouts entirely.
+ */
+async function* iterateWithTimeout(iterator, timeoutMs, onTimeout) {
+    const asyncIterator = iterator[Symbol.asyncIterator]();
+    let pending = null;
+    let done = false;
+    // If timeout is Infinity or not a positive finite number, disable timeout entirely
+    const timeoutDisabled = !Number.isFinite(timeoutMs) || timeoutMs <= 0;
+    try {
+        while (true) {
+            if (!pending) {
+                pending = asyncIterator.next();
+            }
+            let result;
+            if (timeoutDisabled) {
+                // No timeout - just wait for the next value
+                result = await pending;
+            }
+            else {
+                // Race between pending result and timeout
+                const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve({ __timeout: true }), timeoutMs));
+                result = await Promise.race([pending, timeoutPromise]);
+            }
+            if ('__timeout' in result) {
+                onTimeout?.();
+                yield result;
+                continue;
+            }
+            pending = null;
+            if (result.done) {
+                done = true;
+                return;
+            }
+            yield result.value;
+        }
+    }
+    finally {
+        if (!done && typeof asyncIterator.return === 'function') {
+            try {
+                await asyncIterator.return(undefined);
+            }
+            catch {
+                // Ignore return errors
+            }
+        }
+    }
+}
+let cachedVersion = null;
+// Get version from package.json
+function getVersion() {
+    if (cachedVersion)
+        return cachedVersion;
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const pkgPath = resolve(dirname(__filename), '../../package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        cachedVersion = pkg.version || '0.0.0';
+        return cachedVersion;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/**
+ * Compose the lines shown when the interactive shell opens. Deliberately NOT a
+ * marketing splash — bare `erosolar` opens straight into the chat (like
+ * `claude`); this is just the load-bearing status: either how to set a key, or
+ * the active model + masked key. Pure (no chalk/ANSI, no I/O) so the
+ * "no brand banner, key guidance kept" contract is unit-testable without a PTY.
+ * The live renderer colorizes equivalent content; this is the source of truth
+ * for WHICH lines appear.
+ */
+export function composeWelcomeLines(input) {
+    const lines = ['', ...(input.updateLines ?? [])];
+    if (!input.hasApiKey) {
+        lines.push('  ⚠ No API key configured', '', '  Get your key: https://platform.deepseek.com/', '  Set your key: /key YOUR_API_KEY', '');
+    }
+    else {
+        lines.push(`  ${input.model} · ${input.provider}`, `  Key: ${input.maskedKey} · /help for commands`, '');
+    }
+    return lines;
+}
+/**
+ * Run the fully interactive shell with rich UI.
+ */
+export async function runInteractiveShell(options) {
+    // Install signal handlers FIRST for reliable Ctrl+C handling
+    installSignalHandlers();
+    // Initialize protection systems
+    initializeProtection({
+        interceptSignals: true,
+        monitorResources: true,
+        armorExceptions: true,
+        enableWatchdog: true,
+        verbose: process.env['EROSOLAR_DEBUG'] === '1',
+    });
+    // The CLI is interactive-only. There is no piped / one-shot / headless
+    // mode — every session runs through the Ink renderer against a live
+    // terminal. If stdin or stdout isn't a TTY, fail fast with a clear
+    // message rather than emitting unrenderable escape sequences into a
+    // pipe.
+    if (!stdin.isTTY || !stdout.isTTY) {
+        reportStatus('erosolar requires an interactive terminal. Run it directly in a TTY (no pipes, no shell redirection).');
+        exit(1);
+    }
+    loadAllSecrets();
+    const parsed = parseArgs(options.argv);
+    const profile = resolveProfile();
+    const workingDir = process.cwd();
+    const workspaceOptions = resolveWorkspaceCaptureOptions(process.env);
+    const workspaceContext = buildWorkspaceContext(workingDir, workspaceOptions);
+    // Resolve profile config for model info
+    const profileConfig = resolveProfileConfig(profile, workspaceContext);
+    // Create agent controller
+    const controller = await createAgentController({
+        profile,
+        workingDir,
+        workspaceContext,
+        env: process.env,
+    });
+    // Create the interactive shell instance
+    const shell = new InteractiveShell(controller, profile, profileConfig, workingDir);
+    // Handle initial prompt if provided
+    if (parsed.initialPrompt) {
+        shell.queuePrompt(parsed.initialPrompt);
+    }
+    await shell.run();
+}
+class InteractiveShell {
+    controller;
+    profile;
+    profileConfig;
+    workingDir;
+    // The shell holds an `IPromptController`-shaped value. The CLI has a
+    // single renderer — Ink, via InkPromptController. `any` here keeps
+    // existing call signatures unchanged; the interface declares the
+    // same surface but TS would otherwise insist we touch every call
+    // site to declare nullability.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    promptController = null;
+    isProcessing = false;
+    shouldExit = false;
+    pendingPrompts = [];
+    debugEnabled = false;
+    ctrlCCount = 0;
+    lastCtrlCTime = 0;
+    // Set when the user Ctrl+C interrupts a run; suppresses the auto-continue
+    // re-launch in the finally block of processPrompt so the agent doesn't
+    // immediately resume the work the user just cancelled. Cleared when the
+    // user submits a fresh prompt.
+    userInterruptedRun = false;
+    cachedProviders = null;
+    secretInputMode = {
+        active: false,
+        secretId: null,
+        queue: [],
+    };
+    pendingModelSwitch = null;
+    currentResponseBuffer = '';
+    // Store original prompt for auto-continuation
+    originalPromptForAutoContinue = null;
+    // (Pinned prompt removed per request — field intentionally absent.)
+    constructor(controller, profile, profileConfig, workingDir) {
+        this.controller = controller;
+        this.profile = profile;
+        this.profileConfig = profileConfig;
+        this.workingDir = workingDir;
+        // Pre-fetch provider status in background
+        void this.fetchProviders();
+    }
+    async fetchProviders() {
+        try {
+            this.cachedProviders = await quickCheckProviders();
+        }
+        catch {
+            this.cachedProviders = [];
+        }
+    }
+    validateRequiredApiKeys() {
+        const missingKeys = [];
+        // Check DeepSeek API key (required)
+        if (!getSecretValue('DEEPSEEK_API_KEY')) {
+            missingKeys.push('DEEPSEEK_API_KEY');
+        }
+        // Prompt for missing keys directly without showing warning
+        if (missingKeys.length > 0 && this.promptController) {
+            // Queue all missing keys for input
+            this.secretInputMode.queue = missingKeys.slice(1); // Rest of the keys
+            const first = missingKeys[0];
+            if (first) {
+                // Set secret mode immediately to mask input
+                this.secretInputMode.active = true;
+                this.secretInputMode.secretId = first;
+                this.promptController.setSecretMode(true);
+                // Show the inline panel with instructions
+                const secrets = listSecretDefinitions();
+                const secret = secrets.find(s => s.id === first);
+                if (secret && this.promptController.supportsInlinePanel()) {
+                    const lines = [
+                        chalk.bold.hex('#ece6da')(`Set ${secret.label}`),
+                        chalk.dim(secret.description),
+                        '',
+                        chalk.dim('Enter value (or press Enter to skip)'),
+                    ];
+                    this.promptController.setInlinePanel(lines);
+                    this.promptController.setStatusMessage(`Enter ${secret.label}...`);
+                }
+            }
+        }
+    }
+    queuePrompt(prompt) {
+        this.pendingPrompts.push(prompt);
+    }
+    async run() {
+        // createPromptController returns the Ink-backed controller
+        // (src/ui/ink/InkPromptController.ts) — the only renderer. The
+        // dynamic import keeps React/Ink off the cold-start path until
+        // the interactive shell actually starts.
+        const { createPromptController } = await import('../ui/ink/InkPromptController.js');
+        this.promptController = await createPromptController(stdin, stdout, {
+            onSubmit: (text) => this.handleSubmit(text),
+            onQueue: (text) => this.queuePrompt(text),
+            onInterrupt: () => this.handleInterrupt(),
+            onExit: () => this.handleExit(),
+            onCtrlC: (info) => this.handleCtrlC(info),
+            onToggleAutoContinue: () => this.handleAutoContinueToggle(),
+            onToggleHITL: () => this.handleHITLToggle(),
+        });
+        // Register cleanup callback for graceful shutdown
+        onShutdown(() => {
+            this.shouldExit = true;
+            this.promptController?.stop();
+            setStatusSink(null);
+        });
+        setStatusSink((message) => this.promptController?.setStatusMessage(message));
+        // Hand the terminal off to the HITL prompt while it's open: suspend
+        // prompt rendering and detach our keypress handler so arrow keys aren't
+        // double-consumed. Restore both when the prompt closes so the next turn's
+        // input works correctly.
+        const onHitlOpen = () => {
+            const r = this.promptController?.getRenderer();
+            if (!r)
+                return;
+            try {
+                r.suspendPromptRendering();
+            }
+            catch { /* ignore */ }
+            try {
+                r.suspendInputCapture();
+            }
+            catch { /* ignore */ }
+        };
+        const onHitlClose = () => {
+            const r = this.promptController?.getRenderer();
+            if (!r)
+                return;
+            try {
+                r.resumeInputCapture();
+            }
+            catch { /* ignore */ }
+            try {
+                r.resumePromptRendering(true);
+            }
+            catch { /* ignore */ }
+        };
+        hitlEvents.on('prompt-open', onHitlOpen);
+        hitlEvents.on('prompt-close', onHitlClose);
+        onShutdown(() => {
+            hitlEvents.removeListener('prompt-open', onHitlOpen);
+            hitlEvents.removeListener('prompt-close', onHitlClose);
+        });
+        // Start the UI
+        this.promptController.start();
+        this.applyDebugState(this.debugEnabled);
+        // Set up sudo password prompt handler
+        this.setupSudoPasswordHandler();
+        // Set initial status
+        this.promptController.setChromeMeta({
+            directory: this.workingDir,
+        });
+        // Show welcome message
+        await this.showWelcome();
+        // Pinned prompt loading removed — feature stripped per request.
+        // Process any queued prompts
+        if (this.pendingPrompts.length > 0) {
+            const prompts = this.pendingPrompts.splice(0);
+            for (const prompt of prompts) {
+                await this.processPrompt(prompt);
+            }
+        }
+        // Keep running until exit
+        await this.waitForExit();
+    }
+    async showWelcome() {
+        const renderer = this.promptController?.getRenderer();
+        if (!renderer)
+            return;
+        const version = getVersion();
+        // Append to existing terminal history — do not clear scrollback.
+        // Check if DeepSeek API key is set
+        const apiKey = process.env.DEEPSEEK_API_KEY?.trim() || '';
+        const hasApiKey = apiKey.length > 0;
+        // Mask API key: show first 4 and last 4 chars
+        const maskApiKey = (key) => {
+            if (key.length <= 12)
+                return key.slice(0, 3) + '...' + key.slice(-3);
+            return key.slice(0, 6) + '...' + key.slice(-4);
+        };
+        // Update check runs for everyone (no account required), with a hard
+        // race-timeout so a slow registry never delays the banner.
+        const updateLines = [];
+        const updatePromise = Promise.race([
+            checkForUpdates(version).catch(() => null),
+            new Promise((resolve) => setTimeout(() => resolve(null), 2000)),
+        ]);
+        // Resolve the update check BEFORE composing the welcome lines — the
+        // previous order built welcomeLines with `...updateLines` (the array
+        // was empty at that point) and only populated updateLines afterwards,
+        // so the upgrade banner literally never rendered. Bug shipped before
+        // the scoped-package rename made the check return wrong data anyway.
+        const updateInfo = await updatePromise;
+        if (updateInfo?.updateAvailable) {
+            updateLines.push(chalk.cyan('  ⬆ ') +
+                chalk.dim('Update available: ') +
+                chalk.yellow(`v${updateInfo.current}`) +
+                chalk.dim(' → ') +
+                chalk.green(`v${updateInfo.latest}`) +
+                chalk.dim(' · installing in background…'));
+            this.runBackgroundUpdate(updateInfo);
+        }
+        // Clean, minimal welcome - just the essentials
+        const welcomeLines = [
+            '',
+            ...updateLines,
+            '',
+        ];
+        if (!hasApiKey) {
+            // Show API key setup instructions
+            welcomeLines.push(chalk.yellow('  ⚠ No API key configured'), '', chalk.dim('  Get your key: ') + chalk.cyan('https://platform.deepseek.com/'), chalk.dim('  Set your key: ') + chalk.hex('#ffb142')('/key YOUR_API_KEY'), '');
+        }
+        else {
+            const maskedKey = maskApiKey(apiKey);
+            welcomeLines.push(chalk.dim(`  ${this.profileConfig.model} · ${this.profileConfig.provider}`), chalk.dim('  Key: ') + chalk.green(maskedKey) + chalk.dim(' · /help for commands'), '');
+        }
+        const welcomeContent = welcomeLines.join('\n');
+        // Use renderer event system instead of direct stdout writes
+        renderer.addEvent('banner', welcomeContent);
+        // Update renderer meta with model info
+        this.promptController?.setModelContext({
+            model: this.profileConfig.model,
+            provider: this.profileConfig.provider,
+        });
+    }
+    /**
+     * Kick off `npm install -g <pkg>@latest` in a background process. When it
+     * completes, surface a renderer event so the user sees the result without
+     * any blocking. The running CLI keeps the old code — the new version is
+     * picked up on next launch.
+     */
+    runBackgroundUpdate(info) {
+        const renderer = this.promptController?.getRenderer();
+        void performBackgroundUpdate(info, (msg) => {
+            try {
+                renderer?.addEvent('system', msg);
+            }
+            catch { /* ignore */ }
+        }).then((res) => {
+            if (!res.started)
+                return;
+            try {
+                renderer?.addEvent('system', chalk.green(`✓ Update installer launched for v${info.latest}. `) +
+                    chalk.dim('Exit and reopen the CLI to use the new version.'));
+            }
+            catch { /* ignore */ }
+        }).catch(() => { });
+    }
+    /**
+     * Set up handler for sudo password prompts from bash tool execution.
+     * When a sudo command needs a password, this prompts the user securely.
+     */
+    sudoPasswordHandler = null;
+    setupSudoPasswordHandler() {
+        this.sudoPasswordHandler = async () => {
+            const renderer = this.promptController?.getRenderer();
+            if (!renderer) {
+                provideSudoPassword(null);
+                return;
+            }
+            try {
+                // Show password prompt
+                renderer.addEvent('system', chalk.yellow('🔐 Sudo password required'));
+                renderer.setSecretMode(true);
+                renderer.clearBuffer();
+                // Capture password input
+                const password = await renderer.captureInput({ allowEmpty: false, trim: true, resetBuffer: true });
+                // Hide password mode
+                renderer.setSecretMode(false);
+                if (password) {
+                    provideSudoPassword(password);
+                    renderer.addEvent('system', chalk.green('✓ Password provided'));
+                }
+                else {
+                    provideSudoPassword(null);
+                    renderer.addEvent('system', chalk.yellow('Sudo cancelled'));
+                }
+            }
+            catch (error) {
+                renderer.setSecretMode(false);
+                provideSudoPassword(null);
+                reportStatus('Password prompt cancelled');
+            }
+        };
+        onSudoPasswordNeeded(this.sudoPasswordHandler);
+    }
+    cleanupSudoPasswordHandler() {
+        if (this.sudoPasswordHandler) {
+            offSudoPasswordNeeded(this.sudoPasswordHandler);
+            this.sudoPasswordHandler = null;
+        }
+    }
+    applyDebugState(enabled, statusMessage) {
+        this.debugEnabled = enabled;
+        setDebugMode(enabled);
+        this.promptController?.setDebugMode(enabled);
+        // Show transient status message instead of chat banner
+        if (statusMessage) {
+            this.promptController?.setStatusMessage(statusMessage);
+            setTimeout(() => this.promptController?.setStatusMessage(null), 2000);
+        }
+    }
+    describeEventForDebug(event) {
+        switch (event.type) {
+            case 'message.start':
+                return 'message.start';
+            case 'message.delta': {
+                const snippet = debugSnippet(event.content);
+                return snippet ? `message.delta → ${snippet}` : 'message.delta (empty)';
+            }
+            case 'message.complete': {
+                const snippet = debugSnippet(event.content);
+                return snippet
+                    ? `message.complete → ${snippet} (${event.elapsedMs}ms)`
+                    : `message.complete (${event.elapsedMs}ms)`;
+            }
+            case 'tool.start':
+                return `tool.start ${event.toolName}`;
+            case 'tool.complete': {
+                const snippet = debugSnippet(event.result);
+                return snippet
+                    ? `tool.complete ${event.toolName} → ${snippet}`
+                    : `tool.complete ${event.toolName}`;
+            }
+            case 'tool.error':
+                return `tool.error ${event.toolName} → ${event.error}`;
+            case 'edit.explanation': {
+                const snippet = debugSnippet(event.content);
+                return snippet ? `edit.explanation → ${snippet}` : 'edit.explanation';
+            }
+            case 'error':
+                return `error → ${event.error}`;
+            case 'usage': {
+                const parts = [];
+                if (event.inputTokens != null)
+                    parts.push(`in:${event.inputTokens}`);
+                if (event.outputTokens != null)
+                    parts.push(`out:${event.outputTokens}`);
+                if (event.totalTokens != null)
+                    parts.push(`total:${event.totalTokens}`);
+                return `usage ${parts.length ? parts.join(', ') : '(no tokens)'}`;
+            }
+            default:
+                return event.type;
+        }
+    }
+    handleDebugCommand(arg) {
+        const normalized = arg?.toLowerCase();
+        // /debug alone - toggle
+        if (!normalized) {
+            const targetState = !this.debugEnabled;
+            this.applyDebugState(targetState, `Debug ${targetState ? 'on' : 'off'}`);
+            return true;
+        }
+        // /debug status - show current state
+        if (normalized === 'status') {
+            this.promptController?.setStatusMessage(`Debug is ${this.debugEnabled ? 'on' : 'off'}`);
+            setTimeout(() => this.promptController?.setStatusMessage(null), 2000);
+            return true;
+        }
+        // /debug on|enable
+        if (normalized === 'on' || normalized === 'enable') {
+            if (this.debugEnabled) {
+                this.promptController?.setStatusMessage('Debug already on');
+                setTimeout(() => this.promptController?.setStatusMessage(null), 2000);
+                return true;
+            }
+            this.applyDebugState(true, 'Debug on');
+            return true;
+        }
+        // /debug off|disable
+        if (normalized === 'off' || normalized === 'disable') {
+            if (!this.debugEnabled) {
+                this.promptController?.setStatusMessage('Debug already off');
+                setTimeout(() => this.promptController?.setStatusMessage(null), 2000);
+                return true;
+            }
+            this.applyDebugState(false, 'Debug off');
+            return true;
+        }
+        // Invalid argument
+        this.promptController?.setStatusMessage(`Invalid: /debug ${arg}. Use on|off|status`);
+        setTimeout(() => this.promptController?.setStatusMessage(null), 2500);
+        return true;
+    }
+    /**
+     * Synthesize a user-facing response from reasoning content when the model
+     * provides reasoning but no actual response (common with deepseek-v4-pro).
+     * Extracts key conclusions and formats them as a concise response.
+     */
+    synthesizeFromReasoning(reasoning) {
+        if (!reasoning || reasoning.trim().length < 50) {
+            return null;
+        }
+        // Filter out internal meta-reasoning patterns that shouldn't be shown to user
+        const metaPatterns = [
+            /according to the rules?:?/gi,
+            /let me (?:use|search|look|check|find|think|analyze)/gi,
+            /I (?:should|need to|will|can|must) (?:use|search|look|check|find)/gi,
+            /⚡\s*Executing\.*/gi,
+            /use web\s?search/gi,
+            /for (?:non-)?coding (?:questions|tasks)/gi,
+            /answer (?:directly )?from knowledge/gi,
+            /this is a (?:general knowledge|coding|security)/gi,
+            /the user (?:is asking|wants|might be)/gi,
+            /however,? (?:the user|I|we)/gi,
+            /(?:first|next),? (?:I should|let me|I need)/gi,
+        ];
+        let filtered = reasoning;
+        for (const pattern of metaPatterns) {
+            filtered = filtered.replace(pattern, '');
+        }
+        // Split into sentences
+        const sentences = filtered
+            .split(/[.!?\n]+/)
+            .map(s => s.trim())
+            .filter(s => s.length > 20 && !/^[•\-–—*]/.test(s)); // Skip bullets and short fragments
+        if (sentences.length === 0) {
+            return null;
+        }
+        // Look for actual content (not process descriptions)
+        const contentPatterns = [
+            /(?:refers? to|involves?|relates? to|is about|concerns?)/i,
+            /(?:scandal|deal|agreement|proposal|plan|policy)/i,
+            /(?:Trump|Biden|Ukraine|Russia|president|congress)/i,
+            /(?:the (?:main|key|primary)|importantly)/i,
+        ];
+        const contentSentences = [];
+        for (const sentence of sentences) {
+            // Skip sentences that are clearly meta-reasoning
+            if (/^(?:so|therefore|thus|hence|accordingly)/i.test(sentence))
+                continue;
+            if (/(?:I should|let me|I will|I need|I can)/i.test(sentence))
+                continue;
+            for (const pattern of contentPatterns) {
+                if (pattern.test(sentence)) {
+                    contentSentences.push(sentence);
+                    break;
+                }
+            }
+        }
+        // Use content sentences if found, otherwise take last few sentences (often conclusions)
+        const useSentences = contentSentences.length > 0
+            ? contentSentences.slice(0, 3)
+            : sentences.slice(-3);
+        if (useSentences.length === 0) {
+            return null;
+        }
+        const response = useSentences.join('. ').replace(/\.{2,}/g, '.').trim();
+        // Don't prefix with "Based on my analysis" - just return clean content
+        return response.endsWith('.') ? response : response + '.';
+    }
+    async runLocalCommand(command) {
+        const renderer = this.promptController?.getRenderer();
+        if (!command) {
+            this.promptController?.setStatusMessage('Usage: /bash <command>');
+            setTimeout(() => this.promptController?.setStatusMessage(null), 2500);
+            return;
+        }
+        this.promptController?.setStatusMessage(`bash: ${command}`);
+        try {
+            const { stdout: out, stderr } = await exec(command, {
+                cwd: this.workingDir,
+                maxBuffer: 4 * 1024 * 1024,
+            });
+            const output = [out, stderr].filter(Boolean).join('').trim() || '(no output)';
+            renderer?.addEvent('tool', `$ ${command}\n${output}`);
+        }
+        catch (error) {
+            const err = error;
+            const output = [err.stdout, err.stderr, err.message].filter(Boolean).join('\n').trim();
+            renderer?.addEvent('error', `$ ${command}\n${output || 'command failed'}`);
+        }
+        finally {
+            this.promptController?.setStatusMessage(null);
+        }
+    }
+    handleSlashCommand(command) {
+        const trimmed = command.trim();
+        const lower = trimmed.toLowerCase();
+        // Handle /model with arguments - silent model switch
+        if (lower.startsWith('/model ') || lower.startsWith('/m ')) {
+            const arg = trimmed.slice(trimmed.indexOf(' ') + 1).trim();
+            if (arg) {
+                void this.switchModel(arg);
+                return true;
+            }
+        }
+        // Handle /model or /m alone - show interactive model picker menu
+        if (lower === '/model' || lower === '/m') {
+            this.showModelMenu();
+            return true;
+        }
+        // Handle /secrets with subcommands
+        if (lower.startsWith('/secrets') || lower.startsWith('/s ') || lower === '/s') {
+            const parts = trimmed.split(/\s+/);
+            const subCmd = parts[1]?.toLowerCase();
+            if (subCmd === 'set') {
+                const secretArg = parts[2];
+                void this.startSecretInput(secretArg);
+                return true;
+            }
+            // /secrets or /s alone - show status
+            this.showSecrets();
+            return true;
+        }
+        // Handle /key - shortcut to set DEEPSEEK_API_KEY
+        if (lower === '/key' || lower.startsWith('/key ')) {
+            const parts = trimmed.split(/\s+/);
+            const keyValue = parts[1];
+            const renderer = this.promptController?.getRenderer();
+            if (keyValue) {
+                // Direct file write - most reliable method
+                try {
+                    const secretDir = join(homedir(), '.erosolar');
+                    const secretFile = join(secretDir, 'secrets.json');
+                    mkdirSync(secretDir, { recursive: true });
+                    const existing = existsSync(secretFile)
+                        ? JSON.parse(readFileSync(secretFile, 'utf-8'))
+                        : {};
+                    existing['DEEPSEEK_API_KEY'] = keyValue;
+                    writeFileSync(secretFile, JSON.stringify(existing, null, 2) + '\n');
+                    // Also set in process.env for immediate use
+                    process.env['DEEPSEEK_API_KEY'] = keyValue;
+                    // Show confirmation via renderer
+                    renderer?.addEvent('system', chalk.green('✓ DEEPSEEK_API_KEY saved'));
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    renderer?.addEvent('system', chalk.red(`✗ Failed: ${msg}`));
+                }
+            }
+            else {
+                // Show usage hint
+                renderer?.addEvent('system', chalk.yellow('Usage: /key YOUR_API_KEY'));
+            }
+            return true;
+        }
+        if (lower === '/help' || lower === '/h' || lower === '/?') {
+            this.showHelp();
+            return true;
+        }
+        if (lower === '/clear' || lower === '/c') {
+            this.promptController?.clearScreen();
+            void this.showWelcome();
+            return true;
+        }
+        if (lower.startsWith('/bash') || lower.startsWith('/sh ')) {
+            const cmd = trimmed.replace(/^\/(bash|sh)\s*/i, '').trim();
+            void this.runLocalCommand(cmd);
+            return true;
+        }
+        // Pin/unpin slash commands removed. The pinned prompt UI was
+        // pulled per request; commands now silently no-op so existing
+        // bindings don't error.
+        if (lower.startsWith('/pin ') || lower === '/unpin' || lower === '/clearpin') {
+            return true;
+        }
+        // Toggle auto mode: off → on → dual → off
+        if (lower === '/auto' || lower === '/continue' || lower === '/loop' || lower === '/dual') {
+            this.promptController?.toggleAutoContinue();
+            const mode = this.promptController?.getAutoMode() ?? 'off';
+            this.promptController?.setStatusMessage(`Auto: ${mode}`);
+            setTimeout(() => this.promptController?.setStatusMessage(null), 1500);
+            return true;
+        }
+        if (lower === '/exit' || lower === '/quit' || lower === '/q') {
+            this.handleExit();
+            return true;
+        }
+        if (lower.startsWith('/debug')) {
+            const parts = trimmed.split(/\s+/);
+            this.handleDebugCommand(parts[1]);
+            return true;
+        }
+        // Keyboard shortcuts help
+        if (lower === '/keys' || lower === '/shortcuts' || lower === '/kb') {
+            this.showKeyboardShortcuts();
+            return true;
+        }
+        // Toggle the always-on adversarial verifier: /adversarial [on|off|status]
+        if (lower === '/adversarial' || lower.startsWith('/adversarial ')) {
+            const arg = trimmed.split(/\s+/)[1]?.toLowerCase();
+            if (arg === 'on')
+                toggleFeatureFlag('adversarial', true);
+            else if (arg === 'off')
+                toggleFeatureFlag('adversarial', false);
+            else if (arg !== 'status')
+                toggleFeatureFlag('adversarial');
+            const state = loadFeatureFlags().adversarial !== false ? 'on' : 'off';
+            this.promptController?.getRenderer()?.addEvent('system', `Adversarial verification is ${state}.`);
+            return true;
+        }
+        // Toggle ultracode operating mode: /ultracode [on|off|status]
+        if (lower === '/ultracode' || lower.startsWith('/ultracode ')) {
+            const arg = trimmed.split(/\s+/)[1]?.toLowerCase();
+            if (arg === 'on')
+                toggleFeatureFlag('ultracode', true);
+            else if (arg === 'off')
+                toggleFeatureFlag('ultracode', false);
+            else if (arg !== 'status')
+                toggleFeatureFlag('ultracode');
+            const state = loadFeatureFlags().ultracode !== false ? 'on' : 'off';
+            this.promptController?.getRenderer()?.addEvent('system', `Ultracode mode is ${state}. (Applies on the next session — it shapes the system prompt.)`);
+            return true;
+        }
+        // /email and /mail are intentionally unimplemented in the CLI.
+        if (lower.startsWith('/email') || lower.startsWith('/mail')) {
+            this.promptController?.getRenderer()?.addEvent('response', 'Email is not handled by the CLI.');
+            return true;
+        }
+        // Session stats
+        if (lower === '/stats' || lower === '/status') {
+            this.showSessionStats();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Switch model silently without writing to chat.
+     * Accepts formats: "provider", "provider model", "provider/model", or "model"
+     * Updates status bar to show new model.
+     */
+    async switchModel(arg) {
+        // Ensure we have provider info
+        if (!this.cachedProviders) {
+            await this.fetchProviders();
+        }
+        const providers = this.cachedProviders || [];
+        const configuredProviders = getConfiguredProviders();
+        let targetProvider = null;
+        let targetModel = null;
+        // Parse argument: could be "provider model", "provider/model", "provider", or just "model"
+        // Check for space-separated format first: "openai o1-pro"
+        const parts = arg.split(/[\s/]+/);
+        if (parts.length >= 2) {
+            // Try first part as provider
+            const providerMatch = this.matchProvider(parts[0] || '');
+            if (providerMatch) {
+                targetProvider = providerMatch;
+                targetModel = parts.slice(1).join('/'); // Rest is model (handle models with slashes)
+            }
+            else {
+                // First part isn't a provider, treat whole arg as model name
+                const inferredProvider = this.inferProviderFromModel(arg.replace(/\s+/g, '-'));
+                if (inferredProvider) {
+                    targetProvider = inferredProvider;
+                    targetModel = arg.replace(/\s+/g, '-');
+                }
+            }
+        }
+        else {
+            // Single token - could be provider or model
+            const matched = this.matchProvider(arg);
+            if (matched) {
+                targetProvider = matched;
+                // Use provider's best model
+                const providerStatus = providers.find(p => p.provider === targetProvider);
+                targetModel = providerStatus?.latestModel || null;
+            }
+            else {
+                // Assume it's a model name - try to infer provider from model prefix
+                const inferredProvider = this.inferProviderFromModel(arg);
+                if (inferredProvider) {
+                    targetProvider = inferredProvider;
+                    targetModel = arg;
+                }
+            }
+        }
+        // Validate we have a valid provider
+        if (!targetProvider) {
+            // Silent error - just flash status briefly
+            this.promptController?.setStatusMessage(`Unknown: ${arg}`);
+            setTimeout(() => this.promptController?.setStatusMessage(null), 2000);
+            return;
+        }
+        // Check provider is configured
+        const providerInfo = configuredProviders.find(p => p.id === targetProvider);
+        if (!providerInfo) {
+            // Provider not configured - offer to set up API key
+            const secretMap = {
+                'deepseek': 'DEEPSEEK_API_KEY',
+            };
+            const secretId = secretMap[targetProvider];
+            if (secretId) {
+                this.promptController?.setStatusMessage(`${targetProvider} needs API key - setting up...`);
+                // Store the pending model switch to complete after secret is set
+                this.pendingModelSwitch = { provider: targetProvider, model: targetModel };
+                setTimeout(() => this.promptForSecret(secretId), 500);
+                return;
+            }
+            // Provider not supported
+            this.promptController?.setStatusMessage(`${targetProvider} not available - only DeepSeek is supported`);
+            setTimeout(() => this.promptController?.setStatusMessage(null), 2000);
+            return;
+        }
+        // Get model if not specified
+        if (!targetModel) {
+            const providerStatus = providers.find(p => p.provider === targetProvider);
+            targetModel = providerStatus?.latestModel || providerInfo.latestModel;
+        }
+        // Save preference and update config
+        saveModelPreference(this.profile, {
+            provider: targetProvider,
+            model: targetModel,
+        });
+        // Update local config
+        this.profileConfig = {
+            ...this.profileConfig,
+            provider: targetProvider,
+            model: targetModel,
+        };
+        // Update controller's model
+        await this.controller.switchModel({
+            provider: targetProvider,
+            model: targetModel,
+        });
+        // Update status bar - this displays the model below the chat box
+        this.promptController?.setModelContext({
+            model: targetModel,
+            provider: targetProvider,
+        });
+        // Silent success - no chat output, just status bar update
+    }
+    /**
+     * Match user input to a provider ID (fuzzy matching)
+     */
+    matchProvider(input) {
+        const lower = input.toLowerCase();
+        const providers = getConfiguredProviders();
+        // Exact match
+        const exact = providers.find(p => p.id === lower || p.name.toLowerCase() === lower);
+        if (exact)
+            return exact.id;
+        // Prefix match
+        const prefix = providers.find(p => p.id.startsWith(lower) || p.name.toLowerCase().startsWith(lower));
+        if (prefix)
+            return prefix.id;
+        // Alias matching
+        const aliases = {
+            'claude': 'anthropic',
+            'ant': 'anthropic',
+            'gpt': 'openai',
+            'oai': 'openai',
+            'gemini': 'google',
+            'gem': 'google',
+            'ds': 'deepseek',
+            'deep': 'deepseek',
+            'grok': 'xai',
+            'x': 'xai',
+            'local': 'ollama',
+            'llama': 'ollama',
+        };
+        if (aliases[lower]) {
+            const aliased = providers.find(p => p.id === aliases[lower]);
+            if (aliased)
+                return aliased.id;
+        }
+        return null;
+    }
+    /**
+     * Infer provider from model name
+     */
+    inferProviderFromModel(model) {
+        const lower = model.toLowerCase();
+        if (lower.startsWith('claude') || lower.startsWith('opus') || lower.startsWith('sonnet') || lower.startsWith('haiku')) {
+            return 'anthropic';
+        }
+        if (lower.startsWith('gpt') || lower.startsWith('o1') || lower.startsWith('o3') || lower.startsWith('codex')) {
+            return 'openai';
+        }
+        if (lower.startsWith('gemini')) {
+            return 'google';
+        }
+        if (lower.startsWith('deepseek')) {
+            return 'deepseek';
+        }
+        if (lower.startsWith('grok')) {
+            return 'xai';
+        }
+        if (lower.startsWith('llama') || lower.startsWith('mistral') || lower.startsWith('qwen')) {
+            return 'ollama';
+        }
+        return null;
+    }
+    /**
+     * Show interactive model picker menu (Claude Code style).
+     * Auto-discovers latest models from each provider's API.
+     * Uses arrow key navigation with inline panel display.
+     */
+    showModelMenu() {
+        if (!this.promptController?.supportsInlinePanel()) {
+            this.promptController?.setStatusMessage('Use /model <provider> <model> to switch');
+            setTimeout(() => this.promptController?.setStatusMessage(null), 3000);
+            return;
+        }
+        // Show loading indicator
+        this.promptController?.setStatusMessage('Discovering models...');
+        // Fetch latest models from APIs
+        void this.fetchAndShowModelMenu();
+    }
+    /**
+     * Fetch models from provider APIs and show the interactive menu.
+     */
+    async fetchAndShowModelMenu() {
+        try {
+            // Get provider status and cached models
+            const allProviders = getProvidersStatus();
+            const cachedModels = getCachedDiscoveredModels();
+            const currentModel = this.profileConfig.model;
+            const currentProvider = this.profileConfig.provider;
+            // Try to get fresh models from configured providers (with short timeout)
+            let freshStatus = [];
+            try {
+                freshStatus = await Promise.race([
+                    quickCheckProviders(),
+                    new Promise((resolve) => setTimeout(() => resolve([]), 3000))
+                ]);
+            }
+            catch {
+                // Use cached data on error
+            }
+            // Build menu items - group by provider, show models
+            const menuItems = [];
+            for (const provider of allProviders) {
+                // Get models for this provider
+                const providerCachedModels = cachedModels.filter(m => m.provider === provider.id);
+                const freshProvider = freshStatus.find(s => s.provider === provider.id);
+                // Collect model IDs
+                let modelIds = [];
+                // Add fresh latest model if available
+                if (freshProvider?.available && freshProvider.latestModel) {
+                    modelIds.push(freshProvider.latestModel);
+                }
+                // Add cached models
+                modelIds.push(...providerCachedModels.map(m => m.id));
+                // Add provider's default model
+                if (provider.latestModel && !modelIds.includes(provider.latestModel)) {
+                    modelIds.push(provider.latestModel);
+                }
+                // Remove duplicates and sort by priority (best first)
+                modelIds = [...new Set(modelIds)];
+                modelIds = sortModelsByPriority(provider.id, modelIds);
+                // Limit to top 3 models per provider
+                const topModels = modelIds.slice(0, 3);
+                if (!provider.configured) {
+                    // Show unconfigured provider as single disabled item
+                    menuItems.push({
+                        id: `${provider.id}:setup`,
+                        label: `${provider.name}`,
+                        description: `(${provider.envVar} not set - select to configure)`,
+                        category: provider.id,
+                        isActive: false,
+                        disabled: false, // Allow selection to configure
+                    });
+                }
+                else if (topModels.length === 0) {
+                    // No models found - show provider with default
+                    menuItems.push({
+                        id: `${provider.id}:${provider.latestModel}`,
+                        label: `${provider.name} › ${provider.latestModel}`,
+                        description: 'default',
+                        category: provider.id,
+                        isActive: provider.id === currentProvider && provider.latestModel === currentModel,
+                        disabled: false,
+                    });
+                }
+                else {
+                    // Show each model as selectable item
+                    for (const modelId of topModels) {
+                        const isCurrentModel = provider.id === currentProvider && modelId === currentModel;
+                        const modelLabel = this.formatModelLabel(modelId);
+                        menuItems.push({
+                            id: `${provider.id}:${modelId}`,
+                            label: `${provider.name} › ${modelLabel}`,
+                            description: isCurrentModel ? '(current)' : '',
+                            category: provider.id,
+                            isActive: isCurrentModel,
+                            disabled: false,
+                        });
+                    }
+                }
+            }
+            // Clear loading message
+            this.promptController?.setStatusMessage(null);
+            // Show the interactive menu
+            this.promptController?.setMenu(menuItems, { title: '🤖 Select Model' }, (selected) => {
+                if (selected) {
+                    // Parse provider:model format
+                    const [providerId, ...modelParts] = selected.id.split(':');
+                    const modelId = modelParts.join(':');
+                    if (modelId === 'setup') {
+                        // Configure provider API key
+                        const secretMap = {
+                            'deepseek': 'DEEPSEEK_API_KEY',
+                        };
+                        const secretId = secretMap[providerId ?? ''];
+                        if (secretId) {
+                            this.promptForSecret(secretId);
+                        }
+                    }
+                    else {
+                        // Switch to selected model
+                        void this.switchModel(`${providerId} ${modelId}`);
+                    }
+                }
+            });
+        }
+        catch (error) {
+            this.promptController?.setStatusMessage('Failed to load models');
+            setTimeout(() => this.promptController?.setStatusMessage(null), 2000);
+        }
+    }
+    /**
+     * Format model ID for display (shorten long IDs).
+     */
+    formatModelLabel(modelId) {
+        // Shorten common prefixes
+        let label = modelId
+            .replace(/^claude-/, '')
+            .replace(/^gpt-/, 'GPT-')
+            .replace(/^gemini-/, 'Gemini ')
+            .replace(/^deepseek-/, 'DeepSeek ')
+            .replace(/^grok-/, 'Grok ')
+            .replace(/^llama/, 'Llama ')
+            .replace(/^qwen-/, 'Qwen ');
+        // Truncate if too long
+        if (label.length > 30) {
+            label = label.slice(0, 27) + '...';
+        }
+        return label;
+    }
+    showSecrets() {
+        const secrets = listSecretDefinitions();
+        if (!this.promptController?.supportsInlinePanel()) {
+            // Fallback for non-TTY - use status message
+            const setCount = secrets.filter(s => !!process.env[s.envVar]).length;
+            this.promptController?.setStatusMessage(`API Keys: ${setCount}/${secrets.length} configured`);
+            setTimeout(() => this.promptController?.setStatusMessage(null), 3000);
+            return;
+        }
+        // Build interactive menu items
+        const menuItems = secrets.map(secret => {
+            const isSet = !!process.env[secret.envVar];
+            const statusIcon = isSet ? '✓' : '✗';
+            const providers = secret.providers?.length ? ` (${secret.providers.join(', ')})` : '';
+            return {
+                id: secret.id,
+                label: `${statusIcon} ${secret.envVar}`,
+                description: isSet ? 'configured' + providers : 'not set' + providers,
+                isActive: isSet,
+                disabled: false,
+            };
+        });
+        // Show the interactive menu
+        this.promptController.setMenu(menuItems, { title: '🔑 API Keys - Select to Configure' }, (selected) => {
+            if (selected) {
+                // Start secret input for selected key
+                this.promptForSecret(selected.id);
+            }
+        });
+    }
+    /**
+     * Start interactive secret input flow.
+     * If secretArg is provided, set only that secret.
+     * Otherwise, prompt for all unset secrets.
+     */
+    async startSecretInput(secretArg) {
+        const secrets = listSecretDefinitions();
+        if (secretArg) {
+            // Set a specific secret
+            const upper = secretArg.toUpperCase();
+            const secret = secrets.find(s => s.id === upper || s.envVar === upper);
+            if (!secret) {
+                this.promptController?.setStatusMessage(`Unknown secret: ${secretArg}`);
+                setTimeout(() => this.promptController?.setStatusMessage(null), 2000);
+                return;
+            }
+            this.promptForSecret(secret.id);
+            return;
+        }
+        // Queue all unset secrets for input
+        const unsetSecrets = secrets.filter(s => !getSecretValue(s.id));
+        if (unsetSecrets.length === 0) {
+            this.promptController?.setStatusMessage('All secrets configured');
+            setTimeout(() => this.promptController?.setStatusMessage(null), 2000);
+            return;
+        }
+        // Queue all unset secrets and start with the first one
+        this.secretInputMode.queue = unsetSecrets.map(s => s.id);
+        const first = this.secretInputMode.queue.shift();
+        if (first) {
+            this.promptForSecret(first);
+        }
+    }
+    /**
+     * Show prompt for a specific secret and enable secret input mode.
+     */
+    promptForSecret(secretId) {
+        const secrets = listSecretDefinitions();
+        const secret = secrets.find(s => s.id === secretId);
+        if (!secret)
+            return;
+        // Show in inline panel (no chat output)
+        if (this.promptController?.supportsInlinePanel()) {
+            const lines = [
+                chalk.bold.hex('#ece6da')(`Set ${secret.label}`),
+                chalk.dim(secret.description),
+                '',
+                chalk.dim('Enter value (or press Enter to skip)'),
+            ];
+            this.promptController.setInlinePanel(lines);
+        }
+        // Enable secret input mode
+        this.secretInputMode.active = true;
+        this.secretInputMode.secretId = secretId;
+        this.promptController?.setSecretMode(true);
+        this.promptController?.setStatusMessage(`Enter ${secret.label}...`);
+    }
+    /**
+     * Handle secret value submission.
+     */
+    handleSecretValue(value) {
+        const secretId = this.secretInputMode.secretId;
+        if (!secretId)
+            return;
+        // Disable secret mode and clear inline panel
+        this.promptController?.setSecretMode(false);
+        this.promptController?.clearInlinePanel();
+        this.secretInputMode.active = false;
+        this.secretInputMode.secretId = null;
+        let savedSuccessfully = false;
+        if (value.trim()) {
+            try {
+                setSecretValue(secretId, value.trim());
+                this.promptController?.setStatusMessage(`${secretId} saved`);
+                savedSuccessfully = true;
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : 'Failed to save';
+                this.promptController?.setStatusMessage(msg);
+            }
+        }
+        else {
+            this.promptController?.setStatusMessage(`Skipped ${secretId}`);
+        }
+        // Clear status after a moment
+        setTimeout(() => this.promptController?.setStatusMessage(null), 1500);
+        // Process next secret in queue if any
+        if (this.secretInputMode.queue.length > 0) {
+            const next = this.secretInputMode.queue.shift();
+            if (next) {
+                setTimeout(() => this.promptForSecret(next), 500);
+            }
+            return;
+        }
+        // Complete pending model switch if secret was saved successfully
+        if (savedSuccessfully && this.pendingModelSwitch) {
+            const { provider, model } = this.pendingModelSwitch;
+            this.pendingModelSwitch = null;
+            // Refresh provider cache and complete the switch
+            setTimeout(async () => {
+                await this.fetchProviders();
+                await this.switchModel(model ? `${provider} ${model}` : provider);
+            }, 500);
+        }
+    }
+    showHelp() {
+        if (!this.promptController?.supportsInlinePanel()) {
+            this.promptController?.setStatusMessage('Help: /model /secrets /auto /stats /keys /clear /exit');
+            setTimeout(() => this.promptController?.setStatusMessage(null), 3000);
+            return;
+        }
+        const heading = (s) => chalk.bold.hex('#ece6da')(s);
+        const cmd = (s) => chalk.hex('#ffb142')(s);
+        const dim = (s) => chalk.dim(s);
+        const lines = [
+            chalk.bold.hex('#ece6da')('Erosolar Coder Help') + dim('  (press any key to dismiss)'),
+            '',
+            heading('Slash commands'),
+            cmd('/model') + dim('       Cycle provider, or /model <name> to switch'),
+            cmd('/key') + dim('         Set DeepSeek API key for this machine'),
+            cmd('/secrets') + dim('     Show or set provider keys'),
+            cmd('/auto') + dim('        Toggle auto-continue (off → on → dual → off)'),
+            cmd('/bash <cmd>') + dim('  Run a one-shot local shell command'),
+            cmd('/debug') + dim('       Toggle debug mode'),
+            cmd('/adversarial') + dim(' Toggle the adversarial verifier (default on)'),
+            cmd('/ultracode') + dim('   Toggle ultracode operating mode (default on)'),
+            cmd('/stats') + dim('       Show session token + cost stats'),
+            cmd('/keys') + dim('        Show keyboard shortcuts'),
+            cmd('/clear') + dim('       Clear the screen'),
+            cmd('/exit') + dim('        Quit'),
+            '',
+            heading('Quick start'),
+            dim('  1. /key sk-…   (or set ANTHROPIC_API_KEY / OPENAI_API_KEY)'),
+            dim('  2. Type any prompt; the agent reads files, edits, runs commands'),
+            dim('  3. Ctrl+C interrupts an in-flight run'),
+            '',
+            dim('Launch:  erosolar          (interactive)'),
+            dim('         erosolar "task"   (interactive, pre-filled with the prompt)'),
+            dim('Docs:  https://ero.solar/docs   |   README.md'),
+        ];
+        this.promptController.setInlinePanel(lines);
+        this.scheduleInlinePanelDismiss();
+    }
+    showKeyboardShortcuts() {
+        if (!this.promptController?.supportsInlinePanel()) {
+            this.promptController?.setStatusMessage('Use /keys in interactive mode');
+            setTimeout(() => this.promptController?.setStatusMessage(null), 3000);
+            return;
+        }
+        const kb = (key) => chalk.hex('#ffb142')(key);
+        const desc = (text) => chalk.dim(text);
+        const lines = [
+            chalk.bold.hex('#ece6da')('Keyboard Shortcuts') + chalk.dim('  (press any key to dismiss)'),
+            '',
+            chalk.hex('#cbf24e')('Navigation'),
+            `  ${kb('Ctrl+A')} / ${kb('Home')}  ${desc('Move to start of line')}`,
+            `  ${kb('Ctrl+E')} / ${kb('End')}   ${desc('Move to end of line')}`,
+            `  ${kb('Alt+←')} / ${kb('Alt+→')}  ${desc('Move word by word')}`,
+            '',
+            chalk.hex('#cbf24e')('Editing'),
+            `  ${kb('Ctrl+U')}  ${desc('Clear entire line')}`,
+            `  ${kb('Ctrl+W')} / ${kb('Alt+⌫')}  ${desc('Delete word backward')}`,
+            `  ${kb('Ctrl+K')}  ${desc('Delete to end of line')}`,
+            '',
+            chalk.hex('#cbf24e')('Display'),
+            `  ${kb('Ctrl+L')}  ${desc('Clear screen')}`,
+            `  ${kb('Ctrl+O')}  ${desc('Expand last tool result')}`,
+            '',
+            chalk.hex('#cbf24e')('Control'),
+            `  ${kb('Ctrl+C')}  ${desc('Cancel input / interrupt')}`,
+            `  ${kb('Ctrl+D')}  ${desc('Exit (when empty)')}`,
+            `  ${kb('Esc')}     ${desc('Interrupt AI response')}`,
+        ];
+        this.promptController.setInlinePanel(lines);
+        this.scheduleInlinePanelDismiss();
+    }
+    showSessionStats() {
+        if (!this.promptController?.supportsInlinePanel()) {
+            this.promptController?.setStatusMessage('Use /stats in interactive mode');
+            setTimeout(() => this.promptController?.setStatusMessage(null), 3000);
+            return;
+        }
+        const history = this.controller.getHistory();
+        const messageCount = history.length;
+        const userMessages = history.filter(m => m.role === 'user').length;
+        const assistantMessages = history.filter(m => m.role === 'assistant').length;
+        // Calculate approximate token usage from history
+        let totalChars = 0;
+        for (const msg of history) {
+            if (typeof msg.content === 'string') {
+                totalChars += msg.content.length;
+            }
+        }
+        const approxTokens = Math.round(totalChars / 4); // Rough estimate
+        const collapsedCount = this.promptController?.getRenderer?.()?.getCollapsedResultCount?.() ?? 0;
+        const lines = [
+            chalk.bold.hex('#ece6da')('Session Stats') + chalk.dim('  (press any key to dismiss)'),
+            '',
+            chalk.hex('#cbf24e')('Conversation'),
+            `  ${chalk.white(messageCount.toString())} messages (${userMessages} user, ${assistantMessages} assistant)`,
+            `  ${chalk.dim('~')}${chalk.white(approxTokens.toLocaleString())} ${chalk.dim('tokens (estimate)')}`,
+            '',
+            chalk.hex('#cbf24e')('Model'),
+            `  ${chalk.white(this.profileConfig.model)} ${chalk.dim('on')} ${chalk.hex('#ff9352')(this.profileConfig.provider)}`,
+            collapsedCount > 0 ? `  ${chalk.white(collapsedCount.toString())} collapsed results` : '',
+            '',
+            chalk.hex('#cbf24e')('Settings'),
+            `  Debug: ${this.debugEnabled ? chalk.green('on') : chalk.dim('off')}`,
+        ].filter(line => line !== '');
+        this.promptController.setInlinePanel(lines);
+        this.scheduleInlinePanelDismiss();
+    }
+    /**
+     * Auto-dismiss inline panel after timeout or on next input.
+     */
+    inlinePanelDismissTimer = null;
+    scheduleInlinePanelDismiss() {
+        // Clear any existing timer
+        if (this.inlinePanelDismissTimer) {
+            clearTimeout(this.inlinePanelDismissTimer);
+        }
+        // Auto-dismiss after 8 seconds
+        this.inlinePanelDismissTimer = setTimeout(() => {
+            this.promptController?.clearInlinePanel();
+            this.inlinePanelDismissTimer = null;
+        }, 8000);
+    }
+    dismissInlinePanel() {
+        if (this.inlinePanelDismissTimer) {
+            clearTimeout(this.inlinePanelDismissTimer);
+            this.inlinePanelDismissTimer = null;
+        }
+        this.promptController?.clearInlinePanel();
+    }
+    handleSubmit(text) {
+        const trimmed = text.trim();
+        // Handle secret input mode - capture the API key value
+        if (this.secretInputMode.active && this.secretInputMode.secretId) {
+            this.handleSecretValue(trimmed);
+            return;
+        }
+        if (!trimmed) {
+            return;
+        }
+        // Handle slash commands first - these don't go to the AI
+        if (trimmed.startsWith('/')) {
+            if (this.handleSlashCommand(trimmed)) {
+                return;
+            }
+            // Unknown slash command - silent status flash, dismiss inline panel
+            this.dismissInlinePanel();
+            this.promptController?.setStatusMessage(`Unknown: ${trimmed.slice(0, 30)}`);
+            setTimeout(() => this.promptController?.setStatusMessage(null), 2000);
+            return;
+        }
+        // Dismiss inline panel for regular user prompts
+        this.dismissInlinePanel();
+        if (this.isProcessing) {
+            this.pendingPrompts.push(trimmed);
+            return;
+        }
+        void this.processPrompt(trimmed);
+    }
+    async processPrompt(prompt) {
+        if (this.isProcessing) {
+            return;
+        }
+        // Start new run for file change tracking (enables /revert)
+        startNewRun();
+        const sanitizedPrompt = prompt;
+        // Store original prompt for auto-continuation (if not a continuation or auto-generated prompt)
+        if (prompt !== 'continue' && !prompt.startsWith('IMPORTANT:')) {
+            this.originalPromptForAutoContinue = prompt;
+            // A fresh user prompt clears any prior interrupt state — this is new
+            // work the user actually wants done.
+            this.userInterruptedRun = false;
+            // Pinned-prompt persistence removed per request — no longer
+            // displayed above the chat box.
+        }
+        enterCriticalSection();
+        this.isProcessing = true;
+        this.currentResponseBuffer = '';
+        this.promptController?.setStreaming(true);
+        this.promptController?.setStatusMessage('🔄 Analyzing request...');
+        const renderer = this.promptController?.getRenderer();
+        let episodeSuccess = false;
+        const toolsUsed = [];
+        const filesModified = [];
+        // Track reasoning content for fallback when response is empty
+        let reasoningBuffer = '';
+        // Track reasoning-only time to prevent models from reasoning forever without action
+        let reasoningOnlyStartTime = null;
+        let reasoningTimedOut = false;
+        let stepTimedOut = false;
+        let hitlDepth = 0;
+        // Track total prompt processing time to prevent infinite loops
+        const promptStartTime = Date.now();
+        const TOTAL_PROMPT_TIMEOUT_MS = 24 * 60 * 60 * 1000; // 24 hours max for entire prompt without meaningful content
+        let hasReceivedMeaningfulContent = false;
+        // Track response content separately - tool calls don't count for reasoning timeout
+        let hasReceivedResponseContent = false;
+        try {
+            // Use timeout-wrapped iterator to prevent hanging on slow/stuck models
+            for await (const eventOrTimeout of iterateWithTimeout(this.controller.send(sanitizedPrompt), PROMPT_STEP_TIMEOUT_MS)) {
+                // Check for timeout marker
+                if (eventOrTimeout && typeof eventOrTimeout === 'object' && '__timeout' in eventOrTimeout) {
+                    if (hitlDepth > 0) {
+                        this.promptController?.setStatusMessage('⏱ Waiting for human decision...');
+                        continue;
+                    }
+                    stepTimedOut = true;
+                    this.promptController?.setStatusMessage(`⏱ Step timeout (${PROMPT_STEP_TIMEOUT_MS / 1000}s) - completing response`);
+                    // Cancel the controller so the underlying agent stops generating
+                    // events that would never be consumed. Without this the spinner
+                    // can keep ticking against a "ghost" run after the for-await
+                    // loop exits, and any in-flight tool keeps doing work the user
+                    // can't see or stop.
+                    try {
+                        this.controller.cancel('step timeout');
+                    }
+                    catch { /* best-effort */ }
+                    break;
+                }
+                // Check total elapsed time - bail out if too long without meaningful content
+                const totalElapsed = Date.now() - promptStartTime;
+                if (!hasReceivedMeaningfulContent && totalElapsed > TOTAL_PROMPT_TIMEOUT_MS) {
+                    if (renderer) {
+                        renderer.addEvent('response', chalk.yellow(`\n⏱ Response timeout (${Math.round(totalElapsed / 1000)}s) - completing\n`));
+                    }
+                    reasoningTimedOut = true;
+                    try {
+                        this.controller.cancel('response timeout');
+                    }
+                    catch { /* best-effort */ }
+                    break;
+                }
+                const event = eventOrTimeout;
+                if (this.shouldExit) {
+                    break;
+                }
+                switch (event.type) {
+                    case 'message.start':
+                        // AI has started processing - update status to show activity
+                        this.currentResponseBuffer = '';
+                        reasoningBuffer = '';
+                        reasoningOnlyStartTime = null; // Reset on new message
+                        this.promptController?.setStatusMessage('Thinking...');
+                        break;
+                    case 'message.delta':
+                        // Stream content as it arrives
+                        this.currentResponseBuffer += event.content ?? '';
+                        if (renderer) {
+                            renderer.addEvent('stream', event.content);
+                        }
+                        // Reset reasoning timer only when we get actual non-empty content
+                        if (event.content && event.content.trim()) {
+                            reasoningOnlyStartTime = null;
+                            hasReceivedMeaningfulContent = true;
+                            hasReceivedResponseContent = true; // Track actual response content
+                        }
+                        break;
+                    case 'reasoning':
+                        // Accumulate reasoning for potential fallback synthesis
+                        reasoningBuffer += event.content ?? '';
+                        // Update status to show reasoning is actively streaming
+                        this.promptController?.setActivityMessage('Thinking');
+                        // Start the reasoning timer on first reasoning event
+                        if (!reasoningOnlyStartTime) {
+                            reasoningOnlyStartTime = Date.now();
+                        }
+                        // Display useful reasoning as 'thought' events BEFORE the response
+                        // The renderer's curateReasoningContent and shouldRenderThought will filter
+                        // to show only actionable/structured thoughts
+                        if (renderer && event.content?.trim()) {
+                            renderer.addEvent('thought', event.content);
+                        }
+                        break;
+                    case 'message.complete':
+                        // Response complete - clear the thinking indicator
+                        this.promptController?.setStatusMessage(null);
+                        // Response complete - ensure final output includes required "Next steps"
+                        if (renderer) {
+                            // Use the appended field from ensureNextSteps to avoid re-rendering the entire response
+                            const base = (event.content ?? '').trimEnd();
+                            let sourceText = base || this.currentResponseBuffer;
+                            // If content came via message.complete but NOT via deltas, render it now as a proper response
+                            // This handles models that don't stream deltas (e.g., deepseek-v4-pro)
+                            // IMPORTANT: Do NOT re-emit content that was already streamed via 'message.delta' events
+                            // to prevent duplicate display of the same response
+                            if (base && !this.currentResponseBuffer.trim()) {
+                                renderer.addEvent('response', base);
+                            }
+                            // Note: We intentionally DO NOT re-emit currentResponseBuffer as a 'response' event
+                            // because it was already displayed via 'stream' events during message.delta handling
+                            // Fallback: If response is empty but we have reasoning, synthesize a response
+                            if (!sourceText.trim() && reasoningBuffer.trim()) {
+                                // Extract key conclusions from reasoning for display
+                                const synthesized = this.synthesizeFromReasoning(reasoningBuffer);
+                                if (synthesized) {
+                                    renderer.addEvent('response', synthesized);
+                                    sourceText = synthesized;
+                                }
+                            }
+                            episodeSuccess = true; // Mark episode as successful only after we have content
+                            // Only add "Next steps" if tools were actually used (real work done)
+                            // This prevents showing "Next steps" after reasoning-only responses
+                            if (toolsUsed.length > 0) {
+                                const { appended } = ensureNextSteps(sourceText);
+                                // Only stream the newly appended content (e.g., "Next steps:")
+                                // The main response was already added as a response event above
+                                if (appended && appended.trim()) {
+                                    renderer.addEvent('response', appended);
+                                }
+                            }
+                            renderer.addEvent('response', '\n');
+                        }
+                        this.currentResponseBuffer = '';
+                        break;
+                    case 'tool.start': {
+                        const toolName = event.toolName;
+                        const args = event.parameters;
+                        let toolDisplay = `[${toolName}]`;
+                        if (isHitlToolName(toolName)) {
+                            hitlDepth += 1;
+                        }
+                        // Reset reasoning timer when tools are being called (model is taking action)
+                        reasoningOnlyStartTime = null;
+                        hasReceivedMeaningfulContent = true;
+                        if (!toolsUsed.includes(toolName)) {
+                            toolsUsed.push(toolName);
+                        }
+                        const filePath = args?.['file_path'];
+                        if (filePath && (toolName === 'Write' || toolName === 'Edit')) {
+                            if (!filesModified.includes(filePath)) {
+                                filesModified.push(filePath);
+                            }
+                        }
+                        if (toolName === 'Bash' && args?.['command']) {
+                            toolDisplay = `Running: $ ${args['command']}`;
+                        }
+                        else if (toolName === 'Read' && args?.['file_path']) {
+                            toolDisplay += ` ${args['file_path']}`;
+                        }
+                        else if (toolName === 'Write' && args?.['file_path']) {
+                            toolDisplay += ` ${args['file_path']}`;
+                        }
+                        else if (toolName === 'Edit' && args?.['file_path']) {
+                            toolDisplay += ` ${args['file_path']}`;
+                        }
+                        else if (toolName === 'Search' && args?.['pattern']) {
+                            toolDisplay += ` ${args['pattern']}`;
+                        }
+                        else if (toolName === 'Grep' && args?.['pattern']) {
+                            toolDisplay += ` ${args['pattern']}`;
+                        }
+                        else if (toolName === 'WebSearch' && args?.['query']) {
+                            // Surface the query so the user can see exactly what the
+                            // agent is searching for. Without this, every web-search
+                            // turn looked like an opaque "[WebSearch]" in scrollback.
+                            toolDisplay = `🌐 WebSearch: "${String(args['query']).slice(0, 80)}"`;
+                        }
+                        else if (toolName === 'WebExtract') {
+                            const urlsArg = args?.['urls'];
+                            const urls = Array.isArray(urlsArg)
+                                ? urlsArg.filter((u) => typeof u === 'string')
+                                : typeof args?.['url'] === 'string'
+                                    ? [args['url']]
+                                    : [];
+                            const display = urls.length > 0
+                                ? urls.length === 1 ? urls[0] : `${urls[0]} (+${urls.length - 1} more)`
+                                : '...';
+                            toolDisplay = `🌐 WebExtract: ${display}`;
+                        }
+                        if (renderer) {
+                            renderer.addEvent('tool', toolDisplay);
+                        }
+                        // Provide explanatory status messages for different tool types
+                        let statusMsg = '';
+                        if (toolName === 'Bash') {
+                            statusMsg = `Running: ${args?.['command'] ? String(args['command']).slice(0, 40) : '...'}`;
+                        }
+                        else if (toolName === 'Edit' || toolName === 'Write') {
+                            statusMsg = `📝 Editing file: ${args?.['file_path'] || '...'}`;
+                        }
+                        else if (toolName === 'Read') {
+                            statusMsg = `📖 Reading file: ${args?.['file_path'] || '...'}`;
+                        }
+                        else if (toolName === 'Search' || toolName === 'Grep') {
+                            statusMsg = `🔍 Searching: ${args?.['pattern'] ? String(args['pattern']).slice(0, 30) : '...'}`;
+                        }
+                        else if (toolName === 'WebSearch') {
+                            statusMsg = `🌐 Searching web: ${args?.['query'] ? String(args['query']).slice(0, 40) : '...'}`;
+                        }
+                        else if (toolName === 'WebExtract') {
+                            const urlsArg = args?.['urls'];
+                            const firstUrl = Array.isArray(urlsArg)
+                                ? urlsArg.find((u) => typeof u === 'string')
+                                : typeof args?.['url'] === 'string' ? args['url'] : '...';
+                            statusMsg = `🌐 Extracting: ${String(firstUrl ?? '...').slice(0, 50)}`;
+                        }
+                        else {
+                            statusMsg = `🔧 Running ${toolName}...`;
+                        }
+                        this.promptController?.setStatusMessage(statusMsg);
+                        break;
+                    }
+                    case 'tool.complete': {
+                        if (isHitlToolName(event.toolName)) {
+                            hitlDepth = Math.max(0, hitlDepth - 1);
+                        }
+                        // Clear the "Running X..." status since tool is complete
+                        this.promptController?.setStatusMessage('Thinking...');
+                        // Reset reasoning timer after tool completes
+                        reasoningOnlyStartTime = null;
+                        // Show "Done:" prefix for Bash completions
+                        const isBash = event.toolName === 'Bash';
+                        if (isBash && renderer) {
+                            renderer.addEvent('tool', 'Done:');
+                        }
+                        // Pass full result to renderer - it handles display truncation
+                        // and stores full content for Ctrl+O expansion
+                        if (event.result && typeof event.result === 'string' && event.result.trim() && renderer) {
+                            renderer.addEvent('tool-result', event.result);
+                        }
+                        break;
+                    }
+                    case 'tool.error':
+                        if (isHitlToolName(event.toolName)) {
+                            hitlDepth = Math.max(0, hitlDepth - 1);
+                        }
+                        // Clear the "Running X..." status since tool errored
+                        this.promptController?.setStatusMessage('Thinking...');
+                        if (renderer) {
+                            renderer.addEvent('error', event.error);
+                        }
+                        break;
+                    case 'error':
+                        if (renderer) {
+                            renderer.addEvent('error', event.error);
+                        }
+                        break;
+                    case 'usage':
+                        this.promptController?.setMetaStatus({
+                            tokensUsed: event.totalTokens,
+                            tokenLimit: 200000, // Approximate limit
+                        });
+                        break;
+                    case 'provider.fallback': {
+                        // Display fallback notification
+                        if (renderer) {
+                            const fallbackMsg = chalk.yellow('⚠ ') +
+                                chalk.dim(`${event.fromProvider}/${event.fromModel} failed: `) +
+                                chalk.hex('#EF4444')(event.reason) +
+                                chalk.dim(' → switching to ') +
+                                chalk.hex('#34D399')(`${event.toProvider}/${event.toModel}`);
+                            renderer.addEvent('banner', fallbackMsg);
+                        }
+                        // Update the model context to reflect the new provider/model
+                        this.profileConfig = {
+                            ...this.profileConfig,
+                            provider: event.toProvider,
+                            model: event.toModel,
+                        };
+                        this.promptController?.setModelContext({
+                            model: event.toModel,
+                            provider: event.toProvider,
+                        });
+                        break;
+                    }
+                    case 'edit.explanation':
+                        // Show explanation for edits made
+                        if (event.content && renderer) {
+                            const filesInfo = event.files?.length ? ` (${event.files.join(', ')})` : '';
+                            renderer.addEvent('response', `${event.content}${filesInfo}`);
+                        }
+                        break;
+                }
+                // Check reasoning timeout on EVERY iteration (not just when reasoning events arrive)
+                // This ensures we bail out even if events are sparse
+                // Use hasReceivedResponseContent (not hasReceivedMeaningfulContent) so timeout
+                // still triggers after tool calls if model just reasons without responding
+                if (reasoningOnlyStartTime && !hasReceivedResponseContent) {
+                    const reasoningElapsed = Date.now() - reasoningOnlyStartTime;
+                    if (reasoningElapsed > PROMPT_REASONING_TIMEOUT_MS) {
+                        if (renderer) {
+                            renderer.addEvent('response', chalk.yellow(`\n⏱ Reasoning timeout (${Math.round(reasoningElapsed / 1000)}s)\n`));
+                        }
+                        reasoningTimedOut = true;
+                    }
+                }
+                // Check if reasoning timeout was triggered - break out of event loop
+                if (reasoningTimedOut) {
+                    // Cancel the controller too; otherwise the for-await drain
+                    // exits but the agent keeps producing events and side-effects
+                    // for the next 30+ seconds with no UI to consume them.
+                    try {
+                        this.controller.cancel('reasoning timeout');
+                    }
+                    catch { /* best-effort */ }
+                    break;
+                }
+            }
+            // After loop: synthesize from reasoning if no response was generated or timed out
+            // This handles models like deepseek-v4-pro that output thinking but empty response
+            // Also handles step timeouts where the model was stuck
+            // IMPORTANT: Don't add "Next steps" when only reasoning occurred - only after real work
+            if ((!episodeSuccess || reasoningTimedOut || stepTimedOut) && reasoningBuffer.trim() && !this.currentResponseBuffer.trim()) {
+                const synthesized = this.synthesizeFromReasoning(reasoningBuffer);
+                if (synthesized && renderer) {
+                    renderer.addEvent('stream', '\n' + synthesized);
+                    // Only add "Next steps" if tools were actually used (real work done)
+                    if (toolsUsed.length > 0) {
+                        const { appended } = ensureNextSteps(synthesized);
+                        if (appended?.trim()) {
+                            renderer.addEvent('stream', appended);
+                        }
+                    }
+                    renderer.addEvent('response', '\n');
+                    episodeSuccess = true;
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (renderer) {
+                renderer.addEvent('error', message);
+            }
+            // Fallback: If we have reasoning content but no response was generated, synthesize one
+            if (!episodeSuccess && reasoningBuffer.trim() && !this.currentResponseBuffer.trim()) {
+                const synthesized = this.synthesizeFromReasoning(reasoningBuffer);
+                if (synthesized && renderer) {
+                    renderer.addEvent('stream', '\n' + synthesized);
+                    renderer.addEvent('response', '\n');
+                    episodeSuccess = true; // Mark as partial success
+                }
+            }
+        }
+        finally {
+            // Exit critical section - allow termination again
+            exitCriticalSection();
+            // Final fallback: If stream ended without message.complete but we have reasoning
+            if (!episodeSuccess && reasoningBuffer.trim() && !this.currentResponseBuffer.trim()) {
+                const synthesized = this.synthesizeFromReasoning(reasoningBuffer);
+                if (synthesized && renderer) {
+                    renderer.addEvent('stream', '\n' + synthesized);
+                    // Only add "Next steps" if tools were actually used (real work done)
+                    if (toolsUsed.length > 0) {
+                        const { appended } = ensureNextSteps(synthesized);
+                        if (appended?.trim()) {
+                            renderer.addEvent('stream', appended);
+                        }
+                    }
+                    renderer.addEvent('response', '\n');
+                    episodeSuccess = true;
+                }
+            }
+            // Detect a model safety refusal in the just-finished turn. When the
+            // model declines the request, the request is *done* — auto-continue
+            // would just resubmit "continue" and start a new spinner cycle, which
+            // is what produced the stuck "Thinking… (4m N s)" timer the user saw.
+            const refusedTurn = isSafetyRefusal(this.currentResponseBuffer);
+            this.isProcessing = false;
+            this.promptController?.setStreaming(false);
+            this.promptController?.setStatusMessage(null);
+            // Belt-and-suspenders: explicitly clear the activity message so the
+            // "Thinking… (esc to interrupt · Ns)" line doesn't linger after the
+            // final reply if setMode→stopSpinnerAnimation races with another
+            // renderPrompt tick.
+            this.promptController?.setActivityMessage(null);
+            // Force an idle re-render so the spinner area is repainted without
+            // the streaming activity line. setStreaming(false) → setMode('idle')
+            // already calls renderPrompt(), but a coalesced spinner tick that
+            // races with the transition can leave the last "Thinking… (Ns)"
+            // frame on screen until the next event. forceRender squashes it.
+            this.promptController?.forceRender();
+            this.currentResponseBuffer = '';
+            // Process any queued prompts
+            if (this.pendingPrompts.length > 0 && !this.shouldExit) {
+                const next = this.pendingPrompts.shift();
+                if (next) {
+                    await this.processPrompt(next);
+                }
+            }
+            else if (refusedTurn) {
+                // Refusal terminates the turn. Don't re-prompt the model — the
+                // user's request is finished from the agent's side. Clear the
+                // stored "original prompt" so a stray Alt+G later doesn't pick
+                // up where this turn left off.
+                this.originalPromptForAutoContinue = null;
+            }
+            else if (!this.shouldExit && !this.userInterruptedRun) {
+                // Auto mode: keep running until user's prompt is fully completed.
+                // Skipped after a Ctrl+C interrupt so we don't immediately resume
+                // the work the user just cancelled.
+                const autoMode = this.promptController?.getAutoMode() ?? 'off';
+                if (autoMode !== 'off') {
+                    // Check if original user prompt is fully completed
+                    const detector = getTaskCompletionDetector();
+                    const analysis = detector.analyzeCompletion(this.currentResponseBuffer, toolsUsed);
+                    // Continue until task is complete
+                    if (!analysis.isComplete) {
+                        this.promptController?.setStatusMessage('Continuing...');
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                        // Generate auto-continue prompt using stored original prompt
+                        const autoPrompt = this.generateAutoContinuePrompt(this.originalPromptForAutoContinue || '', this.currentResponseBuffer, toolsUsed);
+                        if (autoPrompt) {
+                            await this.processPrompt(autoPrompt);
+                        }
+                        else {
+                            // Default continue if no specific auto-prompt generated
+                            await this.processPrompt('continue');
+                        }
+                    }
+                    else {
+                        this.promptController?.setStatusMessage('Task complete');
+                        setTimeout(() => this.promptController?.setStatusMessage(null), 2000);
+                    }
+                }
+            }
+        }
+    }
+    generateAutoContinuePrompt(originalPrompt, response, toolsUsed) {
+        // Highest-priority signal: a test or build is currently failing
+        // in the visible output. Override every other heuristic and force
+        // a sharp, focused next-action prompt — the agent must drill into
+        // the FIRST failure rather than declaring victory.
+        const failingSignal = detectFailingTestOrBuild(response);
+        if (failingSignal) {
+            const noDocsInstruction = `IMPORTANT: Do NOT create markdown files, documentation, summaries, or reports.`;
+            return `${noDocsInstruction} The output above shows a failing test/build (${failingSignal}). Read the FIRST failure carefully, identify the root cause, edit exactly the file(s) needed, then re-run the same test/build command to confirm. Do not stop until that command exits cleanly.`;
+        }
+        // Only auto-continue for certain types of work
+        const hasFileOperations = toolsUsed.some(t => ['Read', 'Write', 'Edit', 'Search', 'Grep'].includes(t));
+        const hasBashOperations = toolsUsed.includes('Bash');
+        if (!hasFileOperations && !hasBashOperations) {
+            return null; // No meaningful work to continue
+        }
+        // Analyze response to determine what to do next
+        const lowercaseResponse = response.toLowerCase();
+        // Check for common patterns that indicate more work is needed
+        if (lowercaseResponse.includes('next steps') ||
+            lowercaseResponse.includes('further') ||
+            lowercaseResponse.includes('additional') ||
+            lowercaseResponse.includes('implement') ||
+            lowercaseResponse.includes('complete') ||
+            lowercaseResponse.includes('finish')) {
+            // Core instruction to prevent documentation spam
+            const noDocsInstruction = `IMPORTANT: Do NOT create markdown files, documentation, summaries, or reports. Focus only on the actual code/implementation work. Perform the next concrete action in the codebase.`;
+            // Generate a follow-up prompt based on the original task
+            if (originalPrompt.includes('fix') || originalPrompt.includes('bug')) {
+                return `${noDocsInstruction} Continue fixing - edit the next file that needs changes.`;
+            }
+            else if (originalPrompt.includes('implement') || originalPrompt.includes('add')) {
+                return `${noDocsInstruction} Continue implementing - write or edit the next piece of code.`;
+            }
+            else if (originalPrompt.includes('refactor') || originalPrompt.includes('clean')) {
+                return `${noDocsInstruction} Continue refactoring - apply changes to the next file.`;
+            }
+            else if (originalPrompt.includes('test')) {
+                return `${noDocsInstruction} Continue with tests - run or fix the next test.`;
+            }
+            else if (originalPrompt.includes('build') || originalPrompt.includes('deploy') || originalPrompt.includes('publish')) {
+                return `${noDocsInstruction} Continue the build/deploy process - execute the next command.`;
+            }
+            else {
+                return `${noDocsInstruction} Continue with the original task "${originalPrompt.slice(0, 100)}..." - perform the next action.`;
+            }
+        }
+        return null;
+    }
+    handleInterrupt() {
+        if (!this.isProcessing) {
+            return;
+        }
+        const renderer = this.promptController?.getRenderer();
+        if (renderer) {
+            renderer.addEvent('banner', chalk.yellow('Interrupted'));
+        }
+        // Actually cancel the in-flight controller run. Without this the
+        // for-await loop in processPrompt keeps consuming events, the spinner
+        // stays up, and the agent grinds through the rest of its tool loop
+        // while the user sees only a "Interrupted" banner. cancel() is a no-op
+        // when there's no active sink, so this is safe to call unconditionally.
+        try {
+            this.controller.cancel('user interrupt via Ctrl+C');
+        }
+        catch {
+            // Best-effort; if the controller is already torn down the next
+            // Ctrl+C will fall through to authorizedShutdown.
+        }
+        // Suppress the auto-continue re-launch in processPrompt's finally
+        // block. Otherwise the agent immediately starts a fresh "continue"
+        // cycle 500ms later and the user has to keep mashing Ctrl+C to keep
+        // up. Cleared when the user submits a new prompt.
+        this.userInterruptedRun = true;
+    }
+    handleAutoContinueToggle() {
+        const autoMode = this.promptController?.getAutoMode() ?? 'off';
+        this.promptController?.setStatusMessage(`Auto: ${autoMode}`);
+        setTimeout(() => this.promptController?.setStatusMessage(null), 1500);
+        // Reset task completion detector when entering any auto mode
+        if (autoMode !== 'off') {
+            const detector = getTaskCompletionDetector();
+            detector.reset();
+            // Clear any stored original prompt
+            this.originalPromptForAutoContinue = null;
+        }
+    }
+    handleHITLToggle() {
+        const mode = this.promptController?.getModeToggleState().hitlMode ?? 'off';
+        getHITL().updateConfig({ autoPause: mode === 'on' });
+        this.promptController?.setStatusMessage(`HITL: ${mode}`);
+        setTimeout(() => this.promptController?.setStatusMessage(null), 1500);
+    }
+    handleCtrlC(info) {
+        const now = Date.now();
+        // Reset count if more than 2 seconds since last Ctrl+C
+        if (now - this.lastCtrlCTime > 2000) {
+            this.ctrlCCount = 0;
+        }
+        this.lastCtrlCTime = now;
+        this.ctrlCCount++;
+        if (info.hadBuffer) {
+            // Clear buffer, reset count
+            this.ctrlCCount = 0;
+            return;
+        }
+        // Always allow double Ctrl+C to exit, even while processing
+        if (this.ctrlCCount >= 2) {
+            // Use authorized shutdown to bypass anti-termination guard
+            void authorizedShutdown(0);
+            this.shouldExit = true;
+            this.ctrlCCount = 0;
+            return;
+        }
+        if (this.isProcessing) {
+            // Interrupt processing on first Ctrl+C, then allow next Ctrl+C to exit
+            this.handleInterrupt();
+            const renderer = this.promptController?.getRenderer();
+            if (renderer) {
+                renderer.addEvent('banner', chalk.dim('Press Ctrl+C again to exit'));
+            }
+            return;
+        }
+        // First Ctrl+C when idle: show hint
+        const renderer = this.promptController?.getRenderer();
+        if (renderer) {
+            renderer.addEvent('banner', chalk.dim('Press Ctrl+C again to exit'));
+        }
+    }
+    handleExit() {
+        this.shouldExit = true;
+        this.cleanupSudoPasswordHandler();
+        this.promptController?.stop();
+        void authorizedShutdown(0);
+    }
+    waitForExit() {
+        return new Promise((resolve) => {
+            const check = () => {
+                if (this.shouldExit) {
+                    resolve();
+                }
+                else {
+                    setTimeout(check, 100);
+                }
+            };
+            check();
+        });
+    }
+}
+function parseArgs(argv) {
+    const promptTokens = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token) {
+            continue;
+        }
+        // Skip known flags
+        if (token.startsWith('--') || token.startsWith('-')) {
+            continue;
+        }
+        promptTokens.push(token);
+    }
+    return {
+        initialPrompt: promptTokens.length ? promptTokens.join(' ').trim() : null,
+    };
+}
+// The --profile / -p flag was removed; the only call site passes nothing.
+// We retain the function as a single source of truth for the hardcoded
+// profile name that downstream config (agent prompt, model, rulebook)
+// keys off of.
+function resolveProfile() {
+    return 'erosolar-code';
+}
+//# sourceMappingURL=interactiveShell.js.map