iosm-cli 0.2.8 → 0.2.10

package/dist/core/agent-session.js

@@ -14,7 +14,7 @@
  */
 import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
-import { isContextOverflow, modelsAreEqual, resetApiProviders, supportsXhigh } from "@mariozechner/pi-ai";
+import { completeSimple, isContextOverflow, modelsAreEqual, resetApiProviders, supportsXhigh } from "@mariozechner/pi-ai";
 import { getDocsPath, getSessionTracePath, isSessionTraceEnabled } from "../config.js";
 import { buildIosmRuntimeDirective, prepareIosmRuntimeContext } from "../iosm/runtime-context.js";
 import { theme } from "../modes/interactive/theme/theme.js";
@@ -35,6 +35,7 @@ import { isReadOnlyProfileName } from "./agent-profiles.js";
 import { applyPostToolUseHooks, applyPreToolUseHooks, applyStopHooks, applyUserPromptSubmitHooks, emptyHooksConfig, } from "./hooks.js";
 import { extractTaskPlanFromAssistantMessage, formatTaskPlanMessageContent, taskPlanSignature, TASK_PLAN_CUSTOM_TYPE, } from "./task-plan.js";
 import { createAllTools, getAllowedFetchMethodsForProfile } from "./tools/index.js";
+import { ULTRATHINK_CHECKPOINT_COMPRESSION_SYSTEM_PROMPT, ULTRATHINK_MAX_CHECKPOINT_CHARS, ULTRATHINK_MAX_ITERATION_INPUT_TOKENS, ULTRATHINK_MAX_RUN_COST, ULTRATHINK_MAX_RUN_INPUT_TOKENS, ULTRATHINK_MAX_RUN_TOTAL_TOKENS, ULTRATHINK_STAGNATION_LIMIT, ULTRATHINK_VISIBLE_PROMPT_PREFIX, buildUltrathinkCheckpointCompressionPrompt, buildUltrathinkBudgetStatusLine, buildUltrathinkComplianceRepairPrompt, buildUltrathinkContextTail, buildUltrathinkEvidenceCatalog, buildUltrathinkIterationPrompt, buildUltrathinkToolGroundingPrompt, buildUltrathinkVisibleIterationPrompt, createInitialUltrathinkCheckpoint, evaluateUltrathinkEvidencePolicy, extractUltrathinkCheckpoint, extractUltrathinkIterationSummary, extractUltrathinkToolEvidence, findLastMeaningfulUserIntent, getUltrathinkPhase, hasUltrathinkEvidenceViolations, isUltrathinkStagnated, normalizeUltrathinkCheckpoint, parseUltrathinkCommand, resolveUltrathinkReadOnlyTools, shouldUltrathinkForceToolGrounding, truncateUltrathinkCheckpoint, ULTRATHINK_USAGE, } from "./ultrathink.js";
 /**
  * Parse a skill block from message text.
  * Returns null if the text doesn't contain a skill block.
@@ -90,6 +91,108 @@ function deriveOrchestrationDisplayText(promptTextWithoutDirective) {
     }
     return task;
 }
+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 detectPromptProtocolIssue(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);
+    // Flag only executable-looking pseudo markup; don't treat inline explanatory mentions as protocol issues.
+    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 buildPromptProtocolCorrectionPrompt(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 boundedOriginal = input.originalPrompt.length > 2_000
+        ? `${input.originalPrompt.slice(0, 2_000).trimEnd()}...`
+        : input.originalPrompt;
+    return [
+        "[TOOL_PROTOCOL_CORRECTION]",
+        `Previous assistant output included ${reasons.join(" and ")} in plain text.`,
+        "These XML-like blocks are not executable tool calls.",
+        "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 tools when available instead of ad-hoc pseudo calls.",
+        "4) If no tool is needed, provide a direct normal 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>",
+        boundedOriginal,
+        "</original_user_request>",
+        "[/TOOL_PROTOCOL_CORRECTION]",
+    ]
+        .filter((line) => typeof line === "string")
+        .join("\n");
+}
+function buildPromptSilentStopRecoveryPrompt(input) {
+    const boundedOriginal = input.originalPrompt.length > 2_000
+        ? `${input.originalPrompt.slice(0, 2_000).trimEnd()}...`
+        : input.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, provide a 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>",
+        boundedOriginal,
+        "</original_user_request>",
+        "[/ASSISTANT_STALL_RECOVERY]",
+    ]
+        .filter((line) => typeof line === "string")
+        .join("\n");
+}
 function buildSubagentOrchestrationDirective(text) {
     const block = parseOrchestrateBlock(text);
     if (block) {
@@ -147,6 +250,7 @@ function buildMetaProfileOrchestrationDirective(text) {
 // ============================================================================
 /** Standard thinking levels */
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
+const MAX_PROMPT_PROTOCOL_AUTO_REPAIR_ATTEMPTS = 2;
 /** Thinking levels including xhigh (for supported models) */
 const THINKING_LEVELS_WITH_XHIGH = ["off", "minimal", "low", "medium", "high", "xhigh"];
 // ============================================================================
@@ -195,6 +299,8 @@ export class AgentSession {
         this._hooksConfig = emptyHooksConfig();
         this._pendingHookNotices = [];
         this._sessionTraceEnabled = isSessionTraceEnabled();
+        this._protocolAutoRepairActive = false;
+        this._ultrathinkActive = false;
         // Track last assistant message for auto-compaction check
         this._lastAssistantMessage = undefined;
         this._lastTaskPlanSignature = undefined;
@@ -962,6 +1068,22 @@ export class AgentSession {
             source: inputSource,
             imageCount: options?.images?.length ?? 0,
         });
+        if (!options?.skipUltrathinkCommand) {
+            const ultrathinkParseResult = parseUltrathinkCommand(text);
+            if (ultrathinkParseResult?.kind === "error") {
+                throw new Error(`${ultrathinkParseResult.error}\n\n${ultrathinkParseResult.usage}`);
+            }
+            if (ultrathinkParseResult?.kind === "command") {
+                await this._runUltrathinkCommand(ultrathinkParseResult.command, { source: inputSource });
+                this._appendSessionTrace({
+                    type: "prompt_handled_by_command",
+                    text,
+                    command: "ultrathink",
+                    iterations: ultrathinkParseResult.command.iterations,
+                });
+                return;
+            }
+        }
         // Handle extension commands first (execute immediately, even during streaming)
         // Extension commands manage their own LLM interaction via iosm.sendMessage()
         if (expandPromptTemplates && text.startsWith("/")) {
@@ -1126,13 +1248,371 @@ export class AgentSession {
                 this.agent.setSystemPrompt(this._baseSystemPrompt);
             }
         }
-        await this.agent.prompt(messages);
-        await this.waitForRetry();
+        const enableProtocolAutoRepair = !options?.skipProtocolAutoRepair && !this._protocolAutoRepairActive;
+        let protocolToolCallsStarted = 0;
+        let latestAssistantProtocolText = "";
+        let latestAssistantMessage;
+        let latestAssistantVisibleText = "";
+        const unsubscribeProtocolMonitor = enableProtocolAutoRepair
+            ? this.subscribe((event) => {
+                if (event.type === "tool_execution_start") {
+                    protocolToolCallsStarted += 1;
+                    return;
+                }
+                if (event.type === "message_end" && event.message.role === "assistant") {
+                    latestAssistantMessage = event.message;
+                    latestAssistantProtocolText = extractAssistantProtocolText(latestAssistantMessage);
+                    latestAssistantVisibleText = extractAssistantVisibleText(latestAssistantMessage);
+                }
+            })
+            : undefined;
+        try {
+            await this.agent.prompt(messages);
+            await this.waitForRetry();
+        }
+        finally {
+            unsubscribeProtocolMonitor?.();
+        }
         this._appendSessionTrace({
             type: "prompt_dispatched",
             messageCount: messages.length,
             text: promptText,
         });
+        if (enableProtocolAutoRepair) {
+            let nextIssue = detectPromptProtocolIssue(latestAssistantProtocolText);
+            let nextSilentStopWithoutOutput = !nextIssue &&
+                latestAssistantMessage?.stopReason === "stop" &&
+                !latestAssistantMessage.content.some((part) => part.type === "toolCall") &&
+                isNonActionableVisibleAssistantText(latestAssistantVisibleText);
+            if (nextIssue || nextSilentStopWithoutOutput) {
+                this._protocolAutoRepairActive = true;
+                try {
+                    for (let repairAttempt = 1; repairAttempt <= MAX_PROMPT_PROTOCOL_AUTO_REPAIR_ATTEMPTS && (nextIssue || nextSilentStopWithoutOutput); repairAttempt += 1) {
+                        const hasPriorToolActivity = protocolToolCallsStarted > 0 || repairAttempt > 1;
+                        const correctionPrompt = nextIssue
+                            ? buildPromptProtocolCorrectionPrompt({
+                                originalPrompt: expandedText,
+                                issue: nextIssue,
+                                hasPriorToolActivity,
+                            })
+                            : buildPromptSilentStopRecoveryPrompt({
+                                originalPrompt: expandedText,
+                                hasPriorToolActivity,
+                            });
+                        this._appendSessionTrace({
+                            type: "prompt_protocol_auto_repair",
+                            originalPrompt: expandedText,
+                            issue: nextIssue ?? { silentStopWithoutOutput: true },
+                            hasPriorToolActivity,
+                            repairAttempt,
+                            maxRepairAttempts: MAX_PROMPT_PROTOCOL_AUTO_REPAIR_ATTEMPTS,
+                        });
+                        await this.prompt(correctionPrompt, {
+                            expandPromptTemplates: false,
+                            skipIosmAutopilot: true,
+                            skipOrchestrationDirective: true,
+                            skipProtocolAutoRepair: true,
+                            source: inputSource,
+                        });
+                        const repairedAssistant = this._findLastAssistantMessage();
+                        const repairedProtocolText = repairedAssistant ? extractAssistantProtocolText(repairedAssistant) : "";
+                        const repairedVisibleText = repairedAssistant ? extractAssistantVisibleText(repairedAssistant) : "";
+                        nextIssue = detectPromptProtocolIssue(repairedProtocolText);
+                        nextSilentStopWithoutOutput =
+                            !nextIssue &&
+                                repairedAssistant?.stopReason === "stop" &&
+                                !repairedAssistant.content.some((part) => part.type === "toolCall") &&
+                                isNonActionableVisibleAssistantText(repairedVisibleText);
+                    }
+                }
+                finally {
+                    this._protocolAutoRepairActive = false;
+                }
+            }
+        }
+    }
+    async _runUltrathinkCommand(command, options) {
+        if (this.isStreaming) {
+            throw new Error("Cannot start /ultrathink while the agent is processing another request.");
+        }
+        if (this.isCompacting) {
+            throw new Error("Cannot start /ultrathink while compaction is running.");
+        }
+        if (this._ultrathinkActive) {
+            throw new Error("An /ultrathink run is already in progress.");
+        }
+        if (!this.model) {
+            throw new Error("No model selected.\n\n" +
+                `Use /login or set an API key environment variable. See ${join(getDocsPath(), "providers.md")}\n\n` +
+                "Then use /model to select a model.");
+        }
+        const apiKey = await this._modelRegistry.getApiKey(this.model);
+        if (!apiKey) {
+            const isOAuth = this._modelRegistry.isUsingOAuth(this.model);
+            if (isOAuth) {
+                throw new Error(`Authentication failed for "${this.model.provider}". ` +
+                    `Credentials may have expired or network is unavailable. ` +
+                    `Run '/login ${this.model.provider}' to re-authenticate.`);
+            }
+            throw new Error(`No API key found for ${this.model.provider}.\n\n` +
+                `Use /login or set an API key environment variable. See ${join(getDocsPath(), "providers.md")}`);
+        }
+        const objective = command.query?.trim() || findLastMeaningfulUserIntent(this.messages);
+        if (!objective) {
+            throw new Error([
+                "Cannot infer an objective for /ultrathink from session context.",
+                "Provide a query explicitly or send a regular user request first.",
+                "",
+                ULTRATHINK_USAGE,
+            ].join("\n"));
+        }
+        const originalTools = this.getActiveToolNames();
+        const availableToolNames = this.getAllTools().map((tool) => tool.name);
+        const readOnlyTools = resolveUltrathinkReadOnlyTools(availableToolNames);
+        if (readOnlyTools.length === 0) {
+            throw new Error([
+                "Cannot start /ultrathink: no read-only tools are currently active.",
+                "Enable at least one analysis tool (for example read/rg/find/semantic_search/fetch/git_read) and retry.",
+            ].join("\n"));
+        }
+        const contextTail = buildUltrathinkContextTail(this.messages);
+        let checkpoint = createInitialUltrathinkCheckpoint(objective);
+        let previousSummary;
+        let accumulatedInputTokens = 0;
+        let accumulatedTotalTokens = 0;
+        let accumulatedCost = 0;
+        let stagnationCount = 0;
+        let targetIterations = command.iterations;
+        let enforceEvidencePolicy = true;
+        const evidenceById = new Map();
+        const mergeEvidence = (messages) => {
+            const evidence = extractUltrathinkToolEvidence(messages);
+            for (const entry of evidence) {
+                evidenceById.set(entry.toolCallId, entry);
+            }
+            return evidence.length;
+        };
+        const registerUsage = (assistantMessage) => {
+            const usage = assistantMessage?.usage;
+            const inputTokens = Number(usage?.input ?? 0);
+            const totalTokens = Number(usage?.totalTokens ?? inputTokens + Number(usage?.output ?? 0));
+            const costTotal = Number(usage?.cost?.total ?? 0);
+            accumulatedInputTokens += inputTokens;
+            accumulatedTotalTokens += totalTokens;
+            accumulatedCost += costTotal;
+            return { inputTokens, totalTokens, costTotal };
+        };
+        const exceedsBudget = (iterationInputTokens) => iterationInputTokens > ULTRATHINK_MAX_ITERATION_INPUT_TOKENS ||
+            accumulatedInputTokens > ULTRATHINK_MAX_RUN_INPUT_TOKENS ||
+            accumulatedTotalTokens > ULTRATHINK_MAX_RUN_TOTAL_TOKENS ||
+            accumulatedCost > ULTRATHINK_MAX_RUN_COST;
+        const runUltrathinkInternalPrompt = async (rawPrompt, displayText) => {
+            this._appendCustomMessageLocally({
+                customType: INTERNAL_UI_META_CUSTOM_TYPE,
+                content: "",
+                display: false,
+                details: {
+                    kind: "orchestration_context",
+                    rawPrompt,
+                    displayText,
+                },
+            });
+            const messageCountBefore = this.messages.length;
+            await this.prompt(rawPrompt, {
+                expandPromptTemplates: false,
+                skipIosmAutopilot: true,
+                skipOrchestrationDirective: true,
+                skipUltrathinkCommand: true,
+                source: options.source,
+            });
+            return this.messages.slice(messageCountBefore);
+        };
+        this._ultrathinkActive = true;
+        this.setActiveToolsByName(readOnlyTools);
+        try {
+            for (let iteration = 1; iteration <= targetIterations; iteration++) {
+                const phase = iteration === targetIterations ? "Synthesis" : getUltrathinkPhase(iteration, targetIterations);
+                const evidenceCatalog = buildUltrathinkEvidenceCatalog([...evidenceById.values()]);
+                const budgetStatus = buildUltrathinkBudgetStatusLine({
+                    accumulatedInputTokens,
+                    accumulatedTotalTokens,
+                    accumulatedCost,
+                });
+                const iterationPrompt = buildUltrathinkIterationPrompt({
+                    iteration,
+                    totalIterations: targetIterations,
+                    phase,
+                    objective,
+                    checkpoint,
+                    previousSummary,
+                    contextTail: iteration === 1 ? contextTail : undefined,
+                    evidenceCatalog,
+                    budgetStatus,
+                });
+                const visibleIterationPrompt = buildUltrathinkVisibleIterationPrompt({
+                    iteration,
+                    totalIterations: targetIterations,
+                    phase,
+                    objective,
+                });
+                const iterationMessages = await runUltrathinkInternalPrompt(iterationPrompt, visibleIterationPrompt);
+                let toolChecksThisIteration = mergeEvidence(iterationMessages);
+                let assistantMessage = this._findLastAssistantMessage();
+                let assistantText = this.getLastAssistantText() ?? "";
+                let iterationUsage = registerUsage(assistantMessage);
+                let iterationInputTokens = iterationUsage.inputTokens;
+                const evaluatePolicy = () => evaluateUltrathinkEvidencePolicy({
+                    text: assistantText,
+                    phase,
+                    toolChecksThisIteration,
+                    knownEvidenceIds: [...evidenceById.keys()],
+                });
+                const shouldGround = shouldUltrathinkForceToolGrounding({
+                    phase,
+                    cumulativeEvidenceCount: evidenceById.size,
+                    toolChecksThisIteration,
+                });
+                if (shouldGround) {
+                    const groundingPrompt = buildUltrathinkToolGroundingPrompt({
+                        iteration,
+                        totalIterations: targetIterations,
+                        phase,
+                        objective,
+                        checkpoint,
+                        availableReadOnlyTools: readOnlyTools,
+                        evidenceCatalog: buildUltrathinkEvidenceCatalog([...evidenceById.values()]),
+                    });
+                    const groundingDisplayText = `${ULTRATHINK_VISIBLE_PROMPT_PREFIX} ${iteration}/${targetIterations} (${phase}) grounding retry. Performing live workspace probes with read-only tools.`;
+                    const groundingMessages = await runUltrathinkInternalPrompt(groundingPrompt, groundingDisplayText);
+                    toolChecksThisIteration += mergeEvidence(groundingMessages);
+                    assistantMessage = this._findLastAssistantMessage();
+                    assistantText = this.getLastAssistantText() ?? "";
+                    iterationUsage = registerUsage(assistantMessage);
+                    iterationInputTokens += iterationUsage.inputTokens;
+                }
+                if (enforceEvidencePolicy) {
+                    let evidencePolicy = evaluatePolicy();
+                    if (hasUltrathinkEvidenceViolations(evidencePolicy)) {
+                        const policyIssues = [];
+                        if (evidencePolicy.missingEvidenceForNumbers) {
+                            policyIssues.push("Quantitative claims are missing `[evidence:<toolCallId>]` tags.");
+                        }
+                        if (evidencePolicy.invalidEvidenceTags.length > 0) {
+                            policyIssues.push(`Unknown evidence tags: ${evidencePolicy.invalidEvidenceTags.join(", ")}`);
+                        }
+                        if (evidencePolicy.needsNoNewEvidenceMarker && !evidencePolicy.hasNoNewEvidenceMarker) {
+                            policyIssues.push("Verify/Synthesis response with no new tool checks must include [NO_NEW_EVIDENCE_OK].");
+                        }
+                        const repairPrompt = buildUltrathinkComplianceRepairPrompt({
+                            iteration,
+                            totalIterations: targetIterations,
+                            phase,
+                            objective,
+                            originalResponse: assistantText,
+                            issues: policyIssues,
+                            checkpoint,
+                            evidenceCatalog: buildUltrathinkEvidenceCatalog([...evidenceById.values()]),
+                        });
+                        const repairDisplayText = `${ULTRATHINK_VISIBLE_PROMPT_PREFIX} ${iteration}/${targetIterations} (${phase}) policy repair. Normalizing evidence links and checkpoint format.`;
+                        const repairMessages = await runUltrathinkInternalPrompt(repairPrompt, repairDisplayText);
+                        toolChecksThisIteration += mergeEvidence(repairMessages);
+                        assistantMessage = this._findLastAssistantMessage();
+                        assistantText = this.getLastAssistantText() ?? "";
+                        iterationUsage = registerUsage(assistantMessage);
+                        iterationInputTokens += iterationUsage.inputTokens;
+                        evidencePolicy = evaluatePolicy();
+                        if (hasUltrathinkEvidenceViolations(evidencePolicy)) {
+                            // Do not fail the entire run; keep the latest usable answer and finish gracefully.
+                            enforceEvidencePolicy = false;
+                            if (iteration < targetIterations) {
+                                targetIterations = Math.min(targetIterations, iteration + 1);
+                            }
+                        }
+                    }
+                }
+                previousSummary = extractUltrathinkIterationSummary(assistantText);
+                const checkpointBeforeIteration = checkpoint;
+                const extractedCheckpoint = extractUltrathinkCheckpoint(assistantText);
+                if (extractedCheckpoint && extractedCheckpoint.trim()) {
+                    checkpoint = normalizeUltrathinkCheckpoint(extractedCheckpoint, objective);
+                }
+                if (checkpoint.length > ULTRATHINK_MAX_CHECKPOINT_CHARS) {
+                    checkpoint = await this._compressUltrathinkCheckpoint(checkpoint, objective, apiKey);
+                }
+                const stagnated = isUltrathinkStagnated({
+                    previousCheckpoint: checkpointBeforeIteration,
+                    nextCheckpoint: checkpoint,
+                    toolChecksThisIteration,
+                });
+                if (stagnated && iteration < targetIterations) {
+                    stagnationCount += 1;
+                    if (stagnationCount >= ULTRATHINK_STAGNATION_LIMIT) {
+                        targetIterations = Math.min(targetIterations, iteration + 1);
+                    }
+                }
+                else {
+                    stagnationCount = 0;
+                }
+                if (iteration < targetIterations && exceedsBudget(iterationInputTokens)) {
+                    targetIterations = Math.min(targetIterations, iteration + 1);
+                }
+            }
+        }
+        finally {
+            this._ultrathinkActive = false;
+            const currentTools = this.getActiveToolNames();
+            const shouldRestore = currentTools.length !== originalTools.length ||
+                currentTools.some((toolName, index) => toolName !== originalTools[index]);
+            if (shouldRestore) {
+                this.setActiveToolsByName(originalTools);
+            }
+        }
+    }
+    async _compressUltrathinkCheckpoint(checkpoint, objective, apiKey) {
+        const model = this.model;
+        const fallback = truncateUltrathinkCheckpoint(normalizeUltrathinkCheckpoint(checkpoint, objective), ULTRATHINK_MAX_CHECKPOINT_CHARS);
+        if (!model)
+            return fallback;
+        const reserveTokens = this.settingsManager.getCompactionReserveTokens();
+        const maxTokens = Math.max(256, Math.min(2048, Math.floor(reserveTokens * 0.4)));
+        try {
+            const response = await completeSimple(model, {
+                systemPrompt: ULTRATHINK_CHECKPOINT_COMPRESSION_SYSTEM_PROMPT,
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "text",
+                                text: buildUltrathinkCheckpointCompressionPrompt({
+                                    objective,
+                                    checkpoint,
+                                    maxChars: ULTRATHINK_MAX_CHECKPOINT_CHARS,
+                                }),
+                            },
+                        ],
+                        timestamp: Date.now(),
+                    },
+                ],
+            }, model.reasoning
+                ? { maxTokens, apiKey, reasoning: "high" }
+                : { maxTokens, apiKey });
+            if (response.stopReason === "error") {
+                return fallback;
+            }
+            const text = response.content
+                .filter((part) => part.type === "text")
+                .map((part) => part.text)
+                .join("\n")
+                .trim();
+            if (!text) {
+                return fallback;
+            }
+            return truncateUltrathinkCheckpoint(normalizeUltrathinkCheckpoint(text, objective), ULTRATHINK_MAX_CHECKPOINT_CHARS);
+        }
+        catch {
+            return fallback;
+        }
     }
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
@@ -2411,6 +2891,13 @@ export class AgentSession {
                         return this._toolPermissionHandler ? this._toolPermissionHandler(request) : true;
                     },
                 },
+                dbRun: {
+                    resolveRuntimeConfig: () => this.settingsManager.getDbToolsSettings(),
+                    permissionGuard: async (request) => {
+                        evaluatePreToolHooks(request);
+                        return this._toolPermissionHandler ? this._toolPermissionHandler(request) : true;
+                    },
+                },
             });
         this._baseToolRegistry = new Map(Object.entries(baseTools).map(([name, tool]) => [name, tool]));
         const extensionsResult = this._resourceLoader.getExtensions();