iosm-cli 0.2.8 → 0.2.10

package/dist/modes/interactive/interactive-mode.js

@@ -11,7 +11,7 @@ import { spawn, spawnSync } from "child_process";
 import { APP_NAME, CHANGELOG_URL, ENV_SESSION_TRACE, ENV_OFFLINE, ENV_SKIP_VERSION_CHECK, getAgentDir, getAuthPath, getDebugLogPath, getModelsPath, getSessionTracePath, getShareViewerUrl, getUpdateInstruction, isSessionTraceEnabled, PACKAGE_NAME, VERSION, } from "../../config.js";
 import { AuthStorage } from "../../core/auth-storage.js";
 import { getAgentProfile, getMainProfileNames, getProfileNames, isReadOnlyProfileName, isValidProfileName, } from "../../core/agent-profiles.js";
-import { parseSkillBlock } from "../../core/agent-session.js";
+import { parseSkillBlock, } from "../../core/agent-session.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage, INTERNAL_UI_META_CUSTOM_TYPE, isInternalUiMetaDetails, } from "../../core/messages.js";
@@ -119,6 +119,211 @@ function extractTaskToolErrorText(result) {
         return candidate.output.trim();
     return undefined;
 }
+const MAX_TOOL_PROTOCOL_REPAIR_ATTEMPTS = 2;
+const MAX_ASSISTANT_CONTINUATION_PROMPTS_PER_TURN = 1;
+function extractAssistantProtocolText(message) {
+    const parts = [];
+    for (const content of message.content) {
+        if (content.type === "text" && typeof content.text === "string" && content.text.trim()) {
+            parts.push(content.text.trim());
+            continue;
+        }
+        if (content.type !== "thinking")
+            continue;
+        const record = content;
+        const thinking = record.thinking;
+        if (typeof thinking === "string" && thinking.trim()) {
+            parts.push(thinking.trim());
+        }
+    }
+    return parts.join("\n\n").trim();
+}
+function extractAssistantVisibleText(message) {
+    return message.content
+        .filter((content) => content.type === "text")
+        .map((content) => content.text.trim())
+        .filter((text) => text.length > 0)
+        .join("\n\n")
+        .trim();
+}
+function isNonActionableVisibleAssistantText(text) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+        return true;
+    return /^\[\s*output\s+truncated[^\]]*\]?\s*\.?$/i.test(trimmed);
+}
+function detectRawToolProtocolIssue(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return undefined;
+    const hasToolCallOpenBlock = /(^|\n)\s*<\s*tool_call\b/i.test(trimmed);
+    const hasToolCallCloseTag = /<\/\s*tool_call\s*>/i.test(trimmed);
+    const hasFunctionBlock = /(^|\n)\s*<\s*function\s*=\s*[A-Za-z0-9._:-]+/i.test(trimmed);
+    const hasParameterBlock = /(^|\n)\s*<\s*parameter\s*=\s*[A-Za-z0-9._:-]+\s*>/i.test(trimmed);
+    // Treat markup as protocol issue only when it resembles an executable pseudo-call structure.
+    // Plain inline mentions like "raw <tool_call>/<function=...> markup" should not trigger repair.
+    const hasToolCallMarkup = (hasToolCallOpenBlock && (hasToolCallCloseTag || hasFunctionBlock || hasParameterBlock)) ||
+        (hasFunctionBlock && hasParameterBlock);
+    const hasDelegateTaskMarkup = /<\s*delegate_task\b/i.test(trimmed) && /<\/\s*delegate_task\s*>/i.test(trimmed);
+    if (!hasToolCallMarkup && !hasDelegateTaskMarkup) {
+        return undefined;
+    }
+    return {
+        hasToolCallMarkup,
+        hasDelegateTaskMarkup,
+    };
+}
+function detectAssistantResumeReason(message) {
+    if (message.stopReason === "aborted")
+        return "user_aborted";
+    if (message.stopReason === "error")
+        return "interrupted_error";
+    return undefined;
+}
+function buildAssistantResumePrompt(input) {
+    const originalPrompt = input.originalPrompt.trim();
+    const boundedOriginalPrompt = originalPrompt.length > 2_000 ? `${originalPrompt.slice(0, 2_000).trimEnd()}...` : originalPrompt;
+    const reasonLine = input.reason === "user_aborted"
+        ? "Previous assistant turn was cancelled before completion."
+        : "Previous assistant turn ended with a tool/model interruption before completion.";
+    return [
+        "[ASSISTANT_RESUME_REQUEST]",
+        reasonLine,
+        "Continue the same user request from current in-memory state.",
+        "Do not repeat completed steps unless required.",
+        "Use only real structured tool calls when tools are needed.",
+        "Do not emit pseudo XML-like tool markup.",
+        "<original_user_request>",
+        boundedOriginalPrompt,
+        "</original_user_request>",
+        "[/ASSISTANT_RESUME_REQUEST]",
+    ].join("\n");
+}
+function buildAssistantContinuationSelectorTitle(reason) {
+    if (reason === "user_aborted") {
+        return "You stopped the current run.\nChoose what to do next:";
+    }
+    return "Tool invocation failed on the model side.\nChoose what to do next:";
+}
+function buildRawToolProtocolCorrectionPrompt(input) {
+    const reasons = [
+        input.issue.hasToolCallMarkup ? "raw <tool_call>/<function=...> markup" : undefined,
+        input.issue.hasDelegateTaskMarkup ? "raw <delegate_task> blocks" : undefined,
+    ].filter((item) => typeof item === "string");
+    const originalPrompt = input.originalPrompt.trim();
+    const boundedOriginalPrompt = originalPrompt.length > 2_000 ? `${originalPrompt.slice(0, 2_000).trimEnd()}...` : originalPrompt;
+    return [
+        "[TOOL_PROTOCOL_CORRECTION]",
+        `Previous assistant output included ${reasons.join(" and ")} in plain text.`,
+        "These XML-like blocks are not executable tool calls and are ignored by the runtime.",
+        "Retry now and follow this protocol exactly:",
+        "1) Do not output XML/pseudo-call tags (<tool_call>, <function=...>, <delegate_task>).",
+        "2) If a tool is needed, emit real structured tool calls only.",
+        "3) Prefer structured built-ins (db_run, typecheck_run, test_run, lint_run) when applicable.",
+        "4) If no tool is needed, return a normal direct answer.",
+        input.hasPriorToolActivity
+            ? "5) Continue from the current in-memory state; avoid repeating already completed tool steps unless necessary."
+            : undefined,
+        "Execute the original user request now.",
+        "<original_user_request>",
+        boundedOriginalPrompt,
+        "</original_user_request>",
+        "[/TOOL_PROTOCOL_CORRECTION]",
+    ]
+        .filter((line) => typeof line === "string")
+        .join("\n");
+}
+function buildRawToolSilentStopRecoveryPrompt(input) {
+    const originalPrompt = input.originalPrompt.trim();
+    const boundedOriginalPrompt = originalPrompt.length > 2_000 ? `${originalPrompt.slice(0, 2_000).trimEnd()}...` : originalPrompt;
+    return [
+        "[ASSISTANT_STALL_RECOVERY]",
+        "Previous assistant output ended with stop but produced no visible text and no executable tool calls.",
+        "Retry now and continue the same request.",
+        "1) Do not return an empty response.",
+        "2) If a tool is needed, emit real structured tool calls.",
+        "3) If no tool is needed, return a normal direct answer.",
+        input.hasPriorToolActivity
+            ? "4) Continue from the current in-memory state; avoid repeating already completed tool steps unless necessary."
+            : undefined,
+        "Execute the original user request now.",
+        "<original_user_request>",
+        boundedOriginalPrompt,
+        "</original_user_request>",
+        "[/ASSISTANT_STALL_RECOVERY]",
+    ]
+        .filter((line) => typeof line === "string")
+        .join("\n");
+}
+async function promptWithRawToolProtocolRepair(input) {
+    let currentPrompt = input.promptText;
+    let currentOptions = {
+        ...(input.promptOptions ?? {}),
+        skipProtocolAutoRepair: true,
+    };
+    for (let repairAttempt = 0; repairAttempt <= MAX_TOOL_PROTOCOL_REPAIR_ATTEMPTS; repairAttempt += 1) {
+        let toolCallsStarted = 0;
+        let latestAssistantProtocolText = "";
+        let latestAssistantStopReason;
+        let latestAssistantVisibleText = "";
+        let latestAssistantHasInlineToolCalls = false;
+        const unsubscribe = typeof input.session.subscribe === "function"
+            ? input.session.subscribe((event) => {
+                if (event.type === "tool_execution_start") {
+                    toolCallsStarted += 1;
+                    return;
+                }
+                if (event.type === "message_end" && event.message.role === "assistant") {
+                    latestAssistantStopReason = event.message.stopReason;
+                    const assistantMessage = event.message;
+                    latestAssistantProtocolText = extractAssistantProtocolText(assistantMessage);
+                    latestAssistantVisibleText = extractAssistantVisibleText(assistantMessage);
+                    latestAssistantHasInlineToolCalls = assistantMessage.content.some((part) => part.type === "toolCall");
+                }
+            })
+            : undefined;
+        try {
+            await input.session.prompt(currentPrompt, currentOptions);
+        }
+        finally {
+            unsubscribe?.();
+        }
+        const issue = detectRawToolProtocolIssue(latestAssistantProtocolText);
+        const silentStopWithoutOutput = !issue &&
+            latestAssistantStopReason === "stop" &&
+            !latestAssistantHasInlineToolCalls &&
+            isNonActionableVisibleAssistantText(latestAssistantVisibleText);
+        if (!issue && !silentStopWithoutOutput) {
+            return;
+        }
+        if (repairAttempt >= MAX_TOOL_PROTOCOL_REPAIR_ATTEMPTS) {
+            await input.onRepairExhausted?.(issue ? "raw_markup" : "silent_stop");
+            return;
+        }
+        const hasPriorToolActivity = toolCallsStarted > 0 || repairAttempt > 0;
+        if (issue) {
+            input.onRepairApplied?.("raw_markup");
+            currentPrompt = buildRawToolProtocolCorrectionPrompt({
+                originalPrompt: input.promptText,
+                issue,
+                hasPriorToolActivity,
+            });
+        }
+        else {
+            input.onRepairApplied?.("silent_stop");
+            currentPrompt = buildRawToolSilentStopRecoveryPrompt({
+                originalPrompt: input.promptText,
+                hasPriorToolActivity,
+            });
+        }
+        currentOptions = {
+            expandPromptTemplates: false,
+            skipOrchestrationDirective: true,
+            skipProtocolAutoRepair: true,
+            source: "interactive",
+        };
+    }
+}
 function buildMetaParallelismCorrection(input) {
     const validationFailure = input.taskToolError && /Validation failed for tool "task"/i.test(input.taskToolError)
         ? input.taskToolError.split("\n").slice(0, 3).join("\n")
@@ -444,6 +649,81 @@ const DOCTOR_CLI_TOOL_SPECS = [
         candidates: ["semgrep"],
         hint: "Install semgrep (pipx install semgrep or pip install semgrep).",
     },
+    {
+        tool: "vitest",
+        candidates: ["vitest"],
+        hint: "Install vitest (npm/pnpm/yarn add -D vitest).",
+    },
+    {
+        tool: "jest",
+        candidates: ["jest"],
+        hint: "Install jest (npm/pnpm/yarn add -D jest).",
+    },
+    {
+        tool: "pytest",
+        candidates: ["python3", "pytest"],
+        hint: "Install pytest (python3 -m pip install pytest or pipx install pytest).",
+    },
+    {
+        tool: "eslint",
+        candidates: ["eslint"],
+        hint: "Install eslint (npm/pnpm/yarn add -D eslint).",
+    },
+    {
+        tool: "prettier",
+        candidates: ["prettier"],
+        hint: "Install prettier (npm/pnpm/yarn add -D prettier).",
+    },
+    {
+        tool: "stylelint",
+        candidates: ["stylelint"],
+        hint: "Install stylelint (npm/pnpm/yarn add -D stylelint).",
+    },
+    {
+        tool: "tsc",
+        candidates: ["tsc"],
+        hint: "Install TypeScript compiler (npm/pnpm/yarn add -D typescript).",
+    },
+    {
+        tool: "vue_tsc",
+        candidates: ["vue-tsc"],
+        hint: "Install vue-tsc (npm/pnpm/yarn add -D vue-tsc).",
+    },
+    {
+        tool: "pyright",
+        candidates: ["pyright"],
+        hint: "Install pyright (npm i -D pyright or pipx install pyright).",
+    },
+    {
+        tool: "mypy",
+        candidates: ["mypy", "python3"],
+        hint: "Install mypy (python3 -m pip install mypy or pipx install mypy).",
+    },
+    {
+        tool: "psql",
+        candidates: ["psql"],
+        hint: "Install PostgreSQL CLI (psql).",
+    },
+    {
+        tool: "mysql",
+        candidates: ["mysql"],
+        hint: "Install MySQL CLI client (mysql).",
+    },
+    {
+        tool: "sqlite3",
+        candidates: ["sqlite3"],
+        hint: "Install sqlite3 CLI.",
+    },
+    {
+        tool: "mongosh",
+        candidates: ["mongosh"],
+        hint: "Install MongoDB shell (mongosh).",
+    },
+    {
+        tool: "redis-cli",
+        candidates: ["redis-cli"],
+        hint: "Install Redis CLI (redis-cli).",
+    },
     {
         tool: "sed",
         candidates: ["sed"],
@@ -1349,6 +1629,31 @@ export class InteractiveMode {
         }
         return null;
     }
+    getUltrathinkArgumentCompletions(prefix) {
+        const hasTrailingSpace = /\\s$/.test(prefix);
+        const tokens = this.parseSlashArgs(prefix);
+        const queryToken = hasTrailingSpace ? "" : (tokens[tokens.length - 1] ?? "");
+        if (tokens.length === 0) {
+            return [
+                { value: "-q", label: "-q", description: `Iterations (default 5, max 12)` },
+                { value: "--iterations", label: "--iterations", description: "Same as -q" },
+            ];
+        }
+        const previousToken = tokens[tokens.length - 2];
+        if (previousToken === "-q" || previousToken === "--iterations") {
+            const values = ["3", "5", "7", "10", "12"];
+            return values
+                .filter((value) => value.startsWith(queryToken))
+                .map((value) => ({ value, label: value, description: "iteration count" }));
+        }
+        if (queryToken.startsWith("-")) {
+            return [
+                { value: "-q", label: "-q", description: `Iterations (default 5, max 12)` },
+                { value: "--iterations", label: "--iterations", description: "Same as -q" },
+            ].filter((item) => item.value.startsWith(queryToken));
+        }
+        return null;
+    }
     setupAutocomplete(fdPath) {
         // Define commands for autocomplete
         const builtinCommands = BUILTIN_SLASH_COMMANDS.filter((command) => this.activeProfileName === "iosm" || !IOSM_PROFILE_ONLY_COMMANDS.has(command.name));
@@ -1406,6 +1711,10 @@ export class InteractiveMode {
         if (swarmCommand) {
             swarmCommand.getArgumentCompletions = (prefix) => this.getSwarmArgumentCompletions(prefix);
         }
+        const ultrathinkCommand = slashCommands.find((command) => command.name === "ultrathink");
+        if (ultrathinkCommand) {
+            ultrathinkCommand.getArgumentCompletions = (prefix) => this.getUltrathinkArgumentCompletions(prefix);
+        }
         // Convert prompt templates to SlashCommand format for autocomplete
         const templateCommands = this.session.promptTemplates.map((cmd) => ({
             name: cmd.name,
@@ -1784,7 +2093,25 @@ export class InteractiveMode {
         while (true) {
             const userInput = await this.getUserInput();
             try {
-                await this.promptWithTaskFallback(userInput);
+                let promptText = userInput;
+                let continuationPrompts = 0;
+                while (true) {
+                    const turnStartMessageCount = this.session.messages.length;
+                    await this.promptWithTaskFallback(promptText);
+                    if (continuationPrompts >= MAX_ASSISTANT_CONTINUATION_PROMPTS_PER_TURN) {
+                        break;
+                    }
+                    const continuationDecision = await this.maybeRequestAgentContinuation(userInput, turnStartMessageCount);
+                    if (!continuationDecision || continuationDecision.action === "stay") {
+                        break;
+                    }
+                    if (continuationDecision.action === "new_session") {
+                        await this.handleClearCommand();
+                        break;
+                    }
+                    continuationPrompts += 1;
+                    promptText = continuationDecision.promptText;
+                }
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
@@ -5342,7 +5669,7 @@ export class InteractiveMode {
                 transport: this.settingsManager.getTransport(),
                 thinkingLevel: this.session.thinkingLevel,
                 availableThinkingLevels: this.session.getAvailableThinkingLevels(),
-                currentTheme: this.settingsManager.getTheme() || "dark",
+                currentTheme: this.settingsManager.getTheme() || "universal",
                 availableThemes: getAvailableThemes(),
                 hideThinkingBlock: this.hideThinkingBlock,
                 collapseChangelog: this.settingsManager.getCollapseChangelog(),
@@ -5506,7 +5833,7 @@ export class InteractiveMode {
                     this.settingsManager.setTheme(themeName);
                     this.ui.invalidate();
                     if (!result.success) {
-                        this.showError(`Failed to load theme "${themeName}": ${result.error}\nFell back to dark theme.`);
+                        this.showError(`Failed to load theme "${themeName}": ${result.error}\nFell back to universal theme.`);
                     }
                 },
                 onThemePreview: (themeName) => {
@@ -8729,7 +9056,9 @@ export class InteractiveMode {
         const mcpConnected = mcpStatuses.filter((status) => status.state === "connected").length;
         const mcpErrored = mcpStatuses.filter((status) => status.state === "error").length;
         const mcpDisabled = mcpStatuses.filter((status) => !status.enabled).length;
-        const cliToolStatuses = resolveDoctorCliToolStatuses();
+        const resolveCliToolStatuses = this.resolveDoctorCliToolStatuses ??
+            resolveDoctorCliToolStatuses;
+        const cliToolStatuses = resolveCliToolStatuses();
         const missingCliTools = cliToolStatuses.filter((status) => !status.available).map((status) => status.tool);
         let semanticStatus;
         let semanticStatusError;
@@ -9195,6 +9524,41 @@ export class InteractiveMode {
             return !(message.stopReason === "aborted" && message.content.length === 0);
         });
     }
+    async maybeRequestAgentContinuation(originalUserInput, turnStartMessageCount) {
+        const recentAssistant = this.session.messages
+            .slice(turnStartMessageCount)
+            .reverse()
+            .find((message) => message.role === "assistant");
+        if (!recentAssistant) {
+            return undefined;
+        }
+        const resumeReason = detectAssistantResumeReason(recentAssistant);
+        if (!resumeReason) {
+            return undefined;
+        }
+        const selected = await this.showExtensionSelector(buildAssistantContinuationSelectorTitle(resumeReason), [
+            "1. Yes, continue agent work",
+            "2. Repeat my original request",
+            "3. No, keep this session",
+            "4. Start a new session",
+        ]);
+        if (selected === "4. Start a new session") {
+            return { action: "new_session" };
+        }
+        if (selected === "2. Repeat my original request") {
+            return { action: "repeat_request", promptText: originalUserInput };
+        }
+        if (selected !== "1. Yes, continue agent work") {
+            return { action: "stay" };
+        }
+        return {
+            action: "resume",
+            promptText: buildAssistantResumePrompt({
+                reason: resumeReason,
+                originalPrompt: originalUserInput,
+            }),
+        };
+    }
     sanitizeAssistantDisplayMessage(message) {
         const hideAllTextForOrchestration = this.activeAssistantOrchestrationContext;
         let changed = false;
@@ -9237,7 +9601,157 @@ export class InteractiveMode {
             normalized === "/capabilities" ||
             normalized === "capabilities");
     }
+    async showProtocolRepairRecoverySelector(reason) {
+        const title = reason === "silent_stop"
+            ? "Model returned empty/non-actionable responses after auto-repair.\nChoose what to do next:"
+            : "Model emitted pseudo tool-call markup after auto-repair.\nChoose what to do next:";
+        const retryNow = "1. Retry now (Recommended)";
+        const repeatOriginal = "2. Repeat original request";
+        const switchModel = "3. Switch model and retry";
+        const keepSession = "4. Keep session";
+        const selected = await this.showExtensionSelector(title, [retryNow, repeatOriginal, switchModel, keepSession]);
+        if (!selected || selected === keepSession)
+            return "keep_session";
+        if (selected === repeatOriginal)
+            return "repeat_original";
+        if (selected === switchModel)
+            return "switch_model_retry";
+        return "retry_now";
+    }
+    async showModelSelectorForImmediateRetry(initialSearchInput, providerFilter) {
+        return await new Promise((resolve) => {
+            let settled = false;
+            const settle = (model) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(model);
+            };
+            this.showSelector((done) => {
+                const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRegistry, this.session.scopedModels, async (model) => {
+                    try {
+                        await this.session.setModel(model);
+                        this.footer.invalidate();
+                        this.updateEditorBorderColor();
+                        this.refreshBuiltInHeader();
+                        done();
+                        this.showStatus(`Model: ${model.provider}/${model.id}`);
+                        this.checkDaxnutsEasterEgg(model);
+                        settle(model);
+                    }
+                    catch (error) {
+                        done();
+                        this.showError(error instanceof Error ? error.message : String(error));
+                        settle(undefined);
+                    }
+                }, () => {
+                    done();
+                    this.ui.requestRender();
+                    settle(undefined);
+                }, initialSearchInput, providerFilter);
+                return { component: selector, focus: selector };
+            });
+        });
+    }
+    async selectModelForImmediateRetry(preferredProvider) {
+        await this.hydrateMissingProviderModelsForSavedAuth();
+        this.session.modelRegistry.refresh();
+        let models = [];
+        try {
+            models = await this.session.modelRegistry.getAvailable();
+        }
+        catch {
+            models = [];
+        }
+        if (models.length === 0) {
+            this.showStatus("No models available");
+            return undefined;
+        }
+        const providerCounts = new Map();
+        for (const model of models) {
+            providerCounts.set(model.provider, (providerCounts.get(model.provider) ?? 0) + 1);
+        }
+        const providers = Array.from(providerCounts.entries()).sort(([a], [b]) => a.localeCompare(b));
+        if (providers.length === 0) {
+            this.showStatus("No providers available");
+            return undefined;
+        }
+        if (preferredProvider) {
+            const preferred = providers.find(([provider]) => provider.toLowerCase() === preferredProvider.toLowerCase());
+            if (preferred) {
+                return await this.showModelSelectorForImmediateRetry(undefined, preferred[0]);
+            }
+        }
+        if (providers.length === 1) {
+            return await this.showModelSelectorForImmediateRetry(undefined, providers[0]?.[0]);
+        }
+        const optionMap = new Map();
+        const options = ["All providers"];
+        for (const [provider, count] of providers) {
+            const optionLabel = `${provider} (${count})`;
+            optionMap.set(optionLabel, provider);
+            options.push(optionLabel);
+        }
+        const selected = await this.showExtensionSelector("/model: choose provider for retry", options);
+        if (!selected)
+            return undefined;
+        if (selected === "All providers") {
+            return await this.showModelSelectorForImmediateRetry();
+        }
+        const provider = optionMap.get(selected);
+        if (!provider) {
+            this.showWarning("Provider selection is no longer available.");
+            return undefined;
+        }
+        return await this.showModelSelectorForImmediateRetry(undefined, provider);
+    }
     async promptWithTaskFallback(userInput) {
+        const handleProtocolRepairApplied = (reason) => {
+            const showWarning = this.showWarning;
+            if (typeof showWarning === "function") {
+                const message = reason === "silent_stop"
+                    ? "Protocol auto-repair: model returned an empty stop response; retrying once."
+                    : "Protocol auto-repair: model emitted raw tool-call markup; retrying once.";
+                showWarning.call(this, message);
+            }
+        };
+        const runPromptWithProtocolRecovery = async (promptText, promptOptions) => {
+            let nextPrompt = promptText;
+            let nextOptions = promptOptions;
+            for (let recoveryAttempt = 0; recoveryAttempt < 3; recoveryAttempt += 1) {
+                let exhaustedReason;
+                await promptWithRawToolProtocolRepair({
+                    session: this.session,
+                    promptText: nextPrompt,
+                    promptOptions: nextOptions,
+                    onRepairApplied: handleProtocolRepairApplied,
+                    onRepairExhausted: async (reason) => {
+                        exhaustedReason = reason;
+                    },
+                });
+                if (!exhaustedReason) {
+                    return;
+                }
+                const selectedAction = await this.showProtocolRepairRecoverySelector(exhaustedReason);
+                if (selectedAction === "keep_session") {
+                    return;
+                }
+                if (selectedAction === "repeat_original") {
+                    nextPrompt = userInput;
+                    nextOptions = undefined;
+                    continue;
+                }
+                if (selectedAction === "switch_model_retry") {
+                    const selectedModel = await this.selectModelForImmediateRetry();
+                    if (!selectedModel) {
+                        return;
+                    }
+                    continue;
+                }
+                // retry_now: rerun current prompt/options
+            }
+            this.showWarning("Protocol auto-repair exhausted repeatedly. Keep session as-is and retry with a different model or a simpler prompt.");
+        };
         const mentionedAgent = this.resolveMentionedAgent(userInput);
         if (mentionedAgent) {
             const cleaned = userInput.replace(/(?:^|\s)@[^\s]+/g, " ").trim();
@@ -9263,7 +9777,7 @@ export class InteractiveMode {
                         "Answer normally and concisely in plain language. Do not run task tool for this query.",
                         "</agent_capability_query>",
                     ].join("\n");
-                    await this.session.prompt(capabilityPrompt, {
+                    await runPromptWithProtocolRecovery(capabilityPrompt, {
                         expandPromptTemplates: false,
                         source: "interactive",
                     });
@@ -9294,7 +9808,7 @@ export class InteractiveMode {
                     : []),
                 "</orchestrate>",
             ].join("\n");
-            await this.session.prompt(mentionPrompt, {
+            await runPromptWithProtocolRecovery(mentionPrompt, {
                 expandPromptTemplates: false,
                 source: "interactive",
             });
@@ -9327,7 +9841,7 @@ export class InteractiveMode {
             });
             return;
         }
-        await this.session.prompt(userInput);
+        await runPromptWithProtocolRecovery(userInput);
     }
     createIosmVerificationEventBridge(options) {
         const loaderMessage = options?.loaderMessage ?? `Verifying workspace... (${appKey(this.keybindings, "interrupt")} to interrupt)`;
@@ -12920,7 +13434,7 @@ The agent will automatically receive IOSM context on every turn.`;
             const themeName = this.settingsManager.getTheme();
             const themeResult = themeName ? setTheme(themeName, true) : { success: true };
             if (!themeResult.success) {
-                this.showError(`Failed to load theme "${themeName}": ${themeResult.error}\nFell back to dark theme.`);
+                this.showError(`Failed to load theme "${themeName}": ${themeResult.error}\nFell back to universal theme.`);
             }
             const editorPaddingX = this.settingsManager.getEditorPaddingX();
             const autocompleteMaxVisible = this.settingsManager.getAutocompleteMaxVisible();