@pentoshi/clai 4.8.4 → 4.9.0

package/dist/agent/runner.js

@@ -1,4 +1,6 @@
 import { join } from "node:path";
+import { hasMcpMentionSyntax } from "../mcp/mentions.js";
+import { isCanonicalToolName } from "../mcp/names.js";
 import { streamWithProvider } from "../llm/router.js";
 import { isProviderFailureStatus } from "../llm/key-rotation.js";
 import { REQUEST_CONTEXT_PREFIX, upsertRequestContextMessage, } from "../llm/system-messages.js";
@@ -6,6 +8,7 @@ import { operationUsageFromError } from "../llm/operation-ledger.js";
 import { contextAttemptFromOperationUsage } from "../llm/context-snapshot.js";
 import { modelContextWindow } from "../llm/token-usage.js";
 import { providerInputTokenBudget } from "../llm/context-windows.js";
+import { resolveBuiltInProfile } from "../llm/provider-profiles.js";
 import { streamAlreadyEmitted } from "../llm/stream-progress.js";
 import { classifyStreamFailure, planStreamRecovery, recordRecoveryAttempt, createStreamRecoveryState, resetStreamRecoveryState, } from "./stream-recovery.js";
 import { modelSupportsVision, resolveToolDialect } from "../llm/capabilities.js";
@@ -49,7 +52,7 @@ import { compactMessagesWithSummary, shouldApplyAutoCompact, COMPACTION_MEMORY_P
 import { buildContextBreakdown, contextBreakdownAuditPayload, describeDominantContextBlock, toolSchemaHash, } from "./context-breakdown.js";
 import { recordRequestTokenObservation } from "../llm/token-estimate-calibration.js";
 import { accountAssembledRequest, RequestOverLimitError, } from "./request-accounting.js";
-import { autoCompactTriggerTokens, dedupeToolContextOutput, freeTierGuardNotices, getReliabilityPolicy, resolveStepMaxTokens, } from "./reliability-policy.js";
+import { autoCompactTriggerTokens, dedupeToolContextOutput, freeTierGuardNotices, getReliabilityPolicy, MAX_OUTPUT_BUDGET_CONTINUATIONS, MAX_STEP_COMPLETION_TOKENS, outputBudgetWasExhausted, resolveStepMaxTokens, } from "./reliability-policy.js";
 import { auditLog } from "../store/logs.js";
 import { loadProjectContext } from "../store/project.js";
 import { loadAgentInstructions } from "../instructions/load.js";
@@ -378,6 +381,7 @@ export async function runAgentTurn(prompt, options = {}) {
         emit({ type: "turn-end", outcome, finalAnswer: rendered, steps });
         return outcome;
     };
+    let mcpLease;
     try {
         emit({
             type: "turn-start",
@@ -387,6 +391,17 @@ export async function runAgentTurn(prompt, options = {}) {
                 : {}),
         });
         const config = getConfig();
+        const mcpRuntime = options.mcp;
+        const mcpMentioned = hasMcpMentionSyntax(prompt);
+        if (mcpRuntime &&
+            (mcpRuntime.getState().selection.mode !== "off" || mcpMentioned)) {
+            await mcpRuntime.ensureReady();
+        }
+        if (mcpRuntime && mcpMentioned)
+            mcpRuntime.applyMentionSelection(prompt);
+        const mcpToolDefinitions = mcpRuntime?.toolDefinitions({ ...(agentMode === "ask" ? { askMode: true } : {}) }) ?? [];
+        mcpLease = mcpRuntime?.beginTurn();
+        const mcpToolNames = mcpToolDefinitions.map((definition) => definition.name);
         const maxSteps = options.maxSteps ?? 70;
         const confirmPort = options.confirm ?? stdioConfirmPort;
         const projectContext = await loadProjectContext();
@@ -402,7 +417,7 @@ export async function runAgentTurn(prompt, options = {}) {
         // image.view is different from optimistic user-attachment handling: once
         // the tool succeeds, the model must actually receive and inspect its bytes.
         // Offer it only with affirmative capability evidence for the active route.
-        const routeToolNames = (routeProvider, routeModel) => availableToolNames().filter((name) => {
+        const routeToolNames = (routeProvider, routeModel) => [...availableToolNames(), ...mcpToolNames].filter((name) => {
             if (name === "image.ocr")
                 return imageOcrEnabled;
             if (name === "image.view") {
@@ -448,16 +463,17 @@ export async function runAgentTurn(prompt, options = {}) {
         const inputTokenBudget = providerInputTokenBudget(provider, model);
         const useCompactSystemPrompt = inputTokenBudget !== undefined;
         const resolveNativeTools = (p, m) => {
-            const dialect = resolveToolDialect(p, m, config.toolCalling);
+            const dialect = resolveToolDialect(p, m, options.toolCalling ?? config.toolCalling);
             return { dialect, native: dialect !== "none" };
         };
         let { dialect: toolDialect, native: nativeToolsActive } = resolveNativeTools(provider, model);
         const selectToolDefs = (native, compact, routeProvider = provider, routeModel = model) => {
             if (!native)
                 return undefined;
-            const base = compact
-                ? getCompactToolDefinitions()
-                : getToolDefinitions();
+            const base = [
+                ...(compact ? getCompactToolDefinitions() : getToolDefinitions()),
+                ...mcpToolDefinitions,
+            ];
             const allow = new Set([
                 ...routeToolNames(routeProvider, routeModel),
                 ...RUNNER_META_TOOL_NAMES,
@@ -570,6 +586,12 @@ export async function runAgentTurn(prompt, options = {}) {
         const systemSections = [
             renderRequestEnvironmentContext({ plan: activePlan }),
         ];
+        const mcpContext = mcpRuntime?.promptContext({
+            nativeTools: false,
+            ...(agentMode === "ask" ? { askMode: true } : {}),
+        });
+        if (mcpContext)
+            systemSections.push(mcpContext);
         if (projectContext) {
             systemSections.push(`Project context from .clai/context.md:\n${projectContext}`);
         }
@@ -723,13 +745,16 @@ export async function runAgentTurn(prompt, options = {}) {
                                 ? "mode"
                                 : content.includes("OUTCOME")
                                     ? "outcome"
-                                    : content.includes("WORKFLOW") || content.includes("FOCUS")
+                                    : content.includes("WORKFLOW") ||
+                                        content.includes("FOCUS") ||
+                                        content.startsWith("WORK PROFILE")
                                         ? "focus"
                                         : "context",
                 content,
                 mandatory: content.startsWith(SKILLS_CATALOG_PREFIX)
                     ? selectedSkillNames.length > 0
                     : content.startsWith("ACTIVE PLAN") ||
+                        content.startsWith("MCP TOOL CONTEXT") ||
                         content.startsWith("ENGAGEMENT SCOPE") ||
                         content.startsWith("REQUEST ENVIRONMENT") ||
                         content.startsWith("Project context from .clai/context.md:") ||
@@ -923,7 +948,6 @@ export async function runAgentTurn(prompt, options = {}) {
             });
         };
         const loopGuard = new LoopGuard();
-        let lastExactPromptTokens = 0;
         // Uncalibrated estimate for the request currently in flight. Paired with the
         // provider's reported prompt size below so the estimator learns this route's
         // bias instead of permanently over-reporting it.
@@ -961,6 +985,7 @@ export async function runAgentTurn(prompt, options = {}) {
         // to actually act instead of silently returning an empty answer.
         let emptyVisibleRetries = 0;
         let truncatedBudgetRounds = 0;
+        let continuationBudgetFloor = 0;
         let retryWithoutThinking = false;
         // Robust stream-failure recovery. When a provider stream/complete fails we
         // try working approaches (backoff, compaction, thinking-off, provider
@@ -1276,7 +1301,11 @@ export async function runAgentTurn(prompt, options = {}) {
         }
         async function executeSingleTool(rawCall, toolEventId, parentSignal) {
             const scratchDir = scratchDirFor(safeCwd());
-            let call = normalizeToolCall(rawCall);
+            const normalizedCall = normalizeToolCall(rawCall);
+            const canonicalMcpName = mcpRuntime?.canonicalizeToolName(normalizedCall.name);
+            let call = canonicalMcpName && canonicalMcpName !== normalizedCall.name
+                ? { ...normalizedCall, name: canonicalMcpName }
+                : normalizedCall;
             const emitVisibleSyntheticReceipt = (result, summary) => {
                 if (!alreadyPrintedIds.has(toolEventId)) {
                     writeToolCall(toolEventId, call);
@@ -1630,7 +1659,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 }
             }
             const scope = await loadScopeForSession(session.sessionId);
-            const decision = classifyToolCall(call, { scope });
+            const decision = mcpRuntime?.classify(call.name) ?? classifyToolCall(call, { scope });
             await auditLog("tool.classified", {
                 call,
                 decision,
@@ -1654,7 +1683,9 @@ export async function runAgentTurn(prompt, options = {}) {
                     call.name === "terminal.send" ||
                     ((call.name === "shell.exec" || call.name === "shell.start") &&
                         !isPlanModeAllowedShellCommand(cmd));
-                const allowed = isPlanModeAllowedTool(call.name) && !shellBlocked;
+                const allowed = (isPlanModeAllowedTool(call.name) ||
+                    mcpRuntime?.classify(call.name)?.level === "safe") &&
+                    !shellBlocked;
                 if (!allowed) {
                     const reason = `plan mode — ${call.name} is blocked (gather-only). ` +
                         `Use any recon/enum/scan/research tool; do not write project files or run active exploits. ` +
@@ -2086,58 +2117,62 @@ export async function runAgentTurn(prompt, options = {}) {
              * could freeze for minutes after "cancelling stalled tool".
              */
             const runToolWithForcedSettle = () => {
-                const work = runToolCall(call, {
-                    signal: toolAc.signal,
-                    requestSecret: options.requestSecret ?? stdioSecretRequester,
-                    onOutput: (chunk) => {
-                        if (toolAc.signal.aborted)
-                            return;
-                        resetStallTimer();
-                        printLive(chunk);
-                    },
-                    confirmed: true,
-                    userPrompt: prompt,
-                    // image.view needs the active route to check vision support and size
-                    // images to the provider's per-image budget.
-                    llmProvider: provider,
-                    llmModel: model,
-                    sessionId: session.sessionId,
-                    ...(delegation?.taskId ? { taskId: delegation.taskId } : {}),
-                    ...(delegation ? { delegationId: delegation.id } : {}),
-                    ...(dispatchedTaskId ? { parentTaskId: dispatchedTaskId } : {}),
-                    wakeOnCompletion: true,
-                    monitor: {
-                        toolName: call.name,
-                        toolEventId,
-                    },
-                    ...(engagementAction && scope
-                        ? {
-                            engagementAuthorization: {
-                                target: engagementDecision?.normalizedTarget || engagementAction.target,
-                                ...(scope.expiresAt ? { expiresAt: scope.expiresAt } : {}),
-                            },
-                            authorizeNetworkHop: async (url, resolvedAddresses) => {
-                                const hop = actionFromUrl({
-                                    url,
-                                    method: engagementAction.method,
-                                    phase: engagementAction.phase,
-                                    capability: engagementAction.capability,
-                                    resolvedAddresses,
-                                });
-                                const hopDecision = evaluateEngagementAction(scope, hop);
-                                await auditLog("engagement.policy.hop", {
-                                    ...(engagementGraph ? { engagementId: engagementGraph.id } : {}),
-                                    ...(engagementRecord ? { actionId: engagementRecord.id } : {}),
-                                    url,
-                                    resolvedAddresses,
-                                    allowed: hopDecision.allowed,
-                                    reason: hopDecision.reason,
-                                });
-                                return { allowed: hopDecision.allowed, reason: hopDecision.reason };
-                            },
-                        }
-                        : {}),
-                });
+                const work = mcpRuntime !== undefined &&
+                    (mcpRuntime.getTool(call.name) !== undefined ||
+                        isCanonicalToolName(call.name))
+                    ? mcpRuntime.callTool(call.name, call.args, { signal: toolAc.signal })
+                    : runToolCall(call, {
+                        signal: toolAc.signal,
+                        requestSecret: options.requestSecret ?? stdioSecretRequester,
+                        onOutput: (chunk) => {
+                            if (toolAc.signal.aborted)
+                                return;
+                            resetStallTimer();
+                            printLive(chunk);
+                        },
+                        confirmed: true,
+                        userPrompt: prompt,
+                        // image.view needs the active route to check vision support and size
+                        // images to the provider's per-image budget.
+                        llmProvider: provider,
+                        llmModel: model,
+                        sessionId: session.sessionId,
+                        ...(delegation?.taskId ? { taskId: delegation.taskId } : {}),
+                        ...(delegation ? { delegationId: delegation.id } : {}),
+                        ...(dispatchedTaskId ? { parentTaskId: dispatchedTaskId } : {}),
+                        wakeOnCompletion: true,
+                        monitor: {
+                            toolName: call.name,
+                            toolEventId,
+                        },
+                        ...(engagementAction && scope
+                            ? {
+                                engagementAuthorization: {
+                                    target: engagementDecision?.normalizedTarget || engagementAction.target,
+                                    ...(scope.expiresAt ? { expiresAt: scope.expiresAt } : {}),
+                                },
+                                authorizeNetworkHop: async (url, resolvedAddresses) => {
+                                    const hop = actionFromUrl({
+                                        url,
+                                        method: engagementAction.method,
+                                        phase: engagementAction.phase,
+                                        capability: engagementAction.capability,
+                                        resolvedAddresses,
+                                    });
+                                    const hopDecision = evaluateEngagementAction(scope, hop);
+                                    await auditLog("engagement.policy.hop", {
+                                        ...(engagementGraph ? { engagementId: engagementGraph.id } : {}),
+                                        ...(engagementRecord ? { actionId: engagementRecord.id } : {}),
+                                        url,
+                                        resolvedAddresses,
+                                        allowed: hopDecision.allowed,
+                                        reason: hopDecision.reason,
+                                    });
+                                    return { allowed: hopDecision.allowed, reason: hopDecision.reason };
+                                },
+                            }
+                            : {}),
+                    });
                 return new Promise((resolve, reject) => {
                     let settled = false;
                     const finishOk = (r) => {
@@ -2886,8 +2921,7 @@ export async function runAgentTurn(prompt, options = {}) {
             });
         }
         async function maybeAutoCompact(reason, force = false) {
-            const beforeRequestTokens = estimateNextRequestTokens(messages);
-            const beforeTokens = Math.max(beforeRequestTokens, lastExactPromptTokens);
+            const beforeTokens = estimateNextRequestTokens(messages);
             const contextLimitTokens = currentContextLimitTokens();
             const compactTrigger = autoCompactTriggerTokens(getReliabilityPolicy(), {
                 provider,
@@ -3025,7 +3059,6 @@ export async function runAgentTurn(prompt, options = {}) {
                 messages.splice(0, messages.length, ...candidateMessages);
                 compactionAttempts.recordSuccess(attemptKey);
                 loopGuard.resetReadOnly();
-                lastExactPromptTokens = 0;
                 // The snapshot predates the rewrite: replaying it would resurrect the
                 // pre-compaction history. The next successful request re-seeds it.
                 lastSuccessfulRequestSnapshot = undefined;
@@ -3172,6 +3205,21 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                     }
                     const contextLimitTokens = currentContextLimitTokens();
+                    const routeOutputTokenLimit = resolveBuiltInProfile({
+                        provider,
+                        model,
+                    }).limits.outputTokens;
+                    stepMaxTokens = resolveStepMaxTokens({
+                        nativeToolsActive,
+                        toolsAttached,
+                        recoveryNudge: retryWithoutThinking,
+                        truncationDepth: truncatedBudgetRounds,
+                        thinkingEnabled: Boolean(config.thinking?.enabled) && !retryWithoutThinking,
+                        minimumTokens: continuationBudgetFloor,
+                        ...(routeOutputTokenLimit !== undefined
+                            ? { outputTokenLimit: routeOutputTokenLimit }
+                            : {}),
+                    });
                     await auditLog("agent.turn", {
                         provider,
                         model,
@@ -3187,13 +3235,10 @@ export async function runAgentTurn(prompt, options = {}) {
                                 ? { contextLimitTokens }
                                 : {}),
                         }),
-                        maxTokensBudget: resolveStepMaxTokens({
-                            nativeToolsActive,
-                            toolsAttached,
-                            recoveryNudge: retryWithoutThinking,
-                            truncationDepth: truncatedBudgetRounds,
-                            thinkingEnabled: Boolean(config.thinking?.enabled) && !retryWithoutThinking,
-                        }),
+                        maxTokensBudget: stepMaxTokens,
+                        ...(routeOutputTokenLimit !== undefined
+                            ? { outputTokenLimit: routeOutputTokenLimit }
+                            : {}),
                     });
                     // Resume / mid-turn abort can leave orphan tool rows or a user
                     // "continue" before tool results. Heal first so multi-key retry and
@@ -3202,14 +3247,6 @@ export async function runAgentTurn(prompt, options = {}) {
                     // ok=true so the model doesn't thrash on fake exit=130 failures.
                     repairToolProtocol(messages);
                     assertValidToolProtocol(messages);
-                    // E3: adaptive completion budget (still large enough for writes).
-                    stepMaxTokens = resolveStepMaxTokens({
-                        nativeToolsActive,
-                        toolsAttached,
-                        recoveryNudge: retryWithoutThinking,
-                        truncationDepth: truncatedBudgetRounds,
-                        thinkingEnabled: Boolean(config.thinking?.enabled) && !retryWithoutThinking,
-                    });
                     try {
                         // MR-007: the fit verdict is taken on the final assembled request —
                         // after protocol repair and every live-state reinjection — and a
@@ -3540,7 +3577,6 @@ export async function runAgentTurn(prompt, options = {}) {
                 model = completion.model;
                 if (completion.usage) {
                     if (completion.usage.exact && completion.usage.promptTokens > 0) {
-                        lastExactPromptTokens = completion.usage.promptTokens;
                         recordRequestTokenObservation({
                             provider: completion.provider,
                             model: completion.model,
@@ -3602,6 +3638,11 @@ export async function runAgentTurn(prompt, options = {}) {
                     ...assistantTextResult,
                     visible: continuedVisible,
                 };
+                const retryReasoning = completion.reasoningArtifacts?.length || completion.reasoningBlock
+                    ? completion
+                    : assistantText.hasThinking
+                        ? { reasoningBlock: { text: assistantText.thinkContent } }
+                        : completion;
                 const commitAssistantRetry = (historyText) => {
                     const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
                     if (!hasShownToolCall) {
@@ -3619,7 +3660,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             });
                         }
                     }
-                    pushAssistantHistory(historyText, completion);
+                    pushAssistantHistory(historyText, retryReasoning);
                     interruptedVisible = "";
                     interruptedReasoning = "";
                     lowYieldResumptions = 0;
@@ -3805,45 +3846,72 @@ export async function runAgentTurn(prompt, options = {}) {
                         malformedNativeArgsRounds = 0;
                     }
                 }
-                if (!canonicalAssistantVisible.trim() && !call) {
-                    const completionTokens = completion.usage?.completionTokens ?? 0;
-                    const hitOutputLimit = completion.finishReason === "length" ||
-                        (completionTokens > 0 && stepMaxTokens > 0 && completionTokens >= stepMaxTokens - 64);
-                    const truncatedRoundText = collapseRepeatedText(completion.text ?? "");
-                    if (hitOutputLimit && truncatedRoundText.trim() && truncatedBudgetRounds < 2) {
-                        truncatedBudgetRounds += 1;
-                        writeNotice("warn", "response hit the output token limit — continuing from where it stopped");
-                        messages.push({
-                            role: "assistant",
-                            content: sanitizeAssistantText(truncatedRoundText),
-                        });
-                        messages.push(recoveryUserMessage("Your previous response was cut off by the output token limit before it completed. " +
-                            "Continue directly from where it stopped — do not restart the analysis or repeat prior text. " +
-                            "Finish briefly: emit the next tool call, or the final answer if the task is complete."));
-                        continue;
-                    }
-                    if (hitOutputLimit &&
-                        !truncatedRoundText.trim() &&
-                        assistantText.hasThinking &&
-                        truncatedBudgetRounds < 4) {
+                const completionTokens = completion.usage?.completionTokens ?? 0;
+                const completionRouteProfile = resolveBuiltInProfile({
+                    provider,
+                    model,
+                });
+                const completionBudget = completionRouteProfile.limits.outputTokens === undefined
+                    ? stepMaxTokens
+                    : Math.min(stepMaxTokens, completionRouteProfile.limits.outputTokens);
+                const hitOutputLimit = outputBudgetWasExhausted({
+                    finishReason: completion.finishReason,
+                    completionTokens,
+                    requestedMaxTokens: completionBudget,
+                });
+                const incompleteNativeStream = nativeToolCalls.length === 0 && streamedNativeCallNames.size > 0;
+                const outputLimitLooksLikeTool = incompleteNativeStream ||
+                    countToolFences(assistantText.visible) > 0 ||
+                    looksLikeTruncatedToolCall(assistantText.visible);
+                if (hitOutputLimit && !call && !outputLimitLooksLikeTool) {
+                    if (truncatedBudgetRounds < MAX_OUTPUT_BUDGET_CONTINUATIONS) {
                         truncatedBudgetRounds += 1;
-                        interruptedReasoning = appendInterruptedReasoning(interruptedReasoning, assistantText.thinkContent);
+                        const desiredContinuationBudget = Math.min(MAX_STEP_COMPLETION_TOKENS, Math.max(completionBudget, completionBudget * 2));
+                        continuationBudgetFloor =
+                            completionRouteProfile.limits.outputTokens === undefined
+                                ? desiredContinuationBudget
+                                : Math.min(desiredContinuationBudget, completionRouteProfile.limits.outputTokens);
+                        retryWithoutThinking =
+                            completionRouteProfile.reasoning.generation !== "mandatory";
+                        if (assistantText.hasThinking) {
+                            interruptedReasoning = appendInterruptedReasoning(interruptedReasoning, assistantText.thinkContent);
+                        }
                         const preservedBudgetReasoning = interruptedReasoning;
-                        writeNotice("warn", "reasoning used the whole output budget — preserving it and widening the budget");
-                        commitAssistantRetry(assistantText.visible);
-                        interruptedReasoning = preservedBudgetReasoning;
+                        if (canonicalAssistantVisible.trim()) {
+                            visibleCommitted = true;
+                            pushAssistantHistory(assistantText.visible, retryReasoning);
+                            interruptedVisible = canonicalAssistantVisible;
+                            lowYieldResumptions = 0;
+                        }
+                        else {
+                            commitAssistantRetry(assistantText.visible);
+                            interruptedReasoning = preservedBudgetReasoning;
+                        }
+                        writeNotice("warn", retryWithoutThinking
+                            ? "response used the whole output budget — preserving it and continuing once with optional reasoning disabled"
+                            : "response used the whole output budget — preserving it and continuing once at the route limit");
                         messages.push(recoveryUserMessage([
-                            "Your previous response spent the entire output budget on reasoning and was cut off before any visible answer. " +
-                                "Do not restart the analysis — your conclusions so far are preserved below. " +
-                                "Wrap up the reasoning now and emit the next tool call or the final answer directly.",
+                            canonicalAssistantVisible.trim()
+                                ? "Your previous response was cut off by the output token limit. Continue from the exact stopping point without repeating any prior text."
+                                : "Your previous response spent the output budget before producing a visible answer. Do not restart the analysis; use the preserved conclusions and answer now.",
+                            retryWithoutThinking
+                                ? "Optional reasoning is disabled for this continuation. Emit the next tool call or final answer directly and briefly."
+                                : "Finish the reasoning briefly, then emit the next tool call or final answer directly.",
                             interruptedReasoningBrief(interruptedReasoning),
                         ]
                             .filter((part) => Boolean(part))
                             .join("\n\n")));
                         continue;
                     }
-                    const incompleteNativeStream = nativeToolCalls.length === 0 &&
-                        streamedNativeCallNames.size > 0;
+                    writeNotice("warn", canonicalAssistantVisible.trim()
+                        ? "response reached the output limit again after its bounded continuation — returning the preserved partial answer"
+                        : "response reached the output limit again after its bounded continuation — stopping without restarting the reasoning");
+                    if (!canonicalAssistantVisible.trim()) {
+                        commitAssistantRetry(assistantText.visible);
+                        return finishTurn("The model exhausted its output budget again after one preserved continuation. No visible answer was produced.", step + 1, "partial", ["Retry at a lower reasoning effort or choose a model with a larger output limit."], "The model exhausted the route's output budget twice without a visible answer.");
+                    }
+                }
+                if (!canonicalAssistantVisible.trim() && !call) {
                     if (incompleteNativeStream) {
                         const reason = "The provider began this native tool call but never completed it. Nothing ran; reissue a complete call.";
                         for (const deferred of deferredToolCalls) {
@@ -3904,6 +3972,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     // Reset the counter on any successful visible output or recovered call.
                     emptyVisibleRetries = 0;
                     truncatedBudgetRounds = 0;
+                    continuationBudgetFloor = 0;
                     retryWithoutThinking = false;
                     interruptedReasoning = "";
                 }
@@ -4233,15 +4302,18 @@ export async function runAgentTurn(prompt, options = {}) {
                         ? "One or more required plan tasks failed."
                         : outcomeStatus === "partial"
                             ? "Required outcome criteria remain unsupported by current evidence."
-                            : undefined, displayCleaned);
+                            : undefined, interruptedVisible ? cleaned : displayCleaned);
                 }
                 // A valid primary tool call exists for this fresh model turn. Show any
                 // prose / thinking that preceded it, record the assistant message ONCE.
+                const toolDisplayText = interruptedVisible
+                    ? canonicalAssistantVisible
+                    : assistantText.visible;
                 const beforeTool = recoveredFromBareJson
                     ? ""
                     : nativeToolCalls.length
-                        ? assistantText.visible.trim()
-                        : textBeforeToolCall(assistantText.visible);
+                        ? toolDisplayText.trim()
+                        : textBeforeToolCall(toolDisplayText);
                 if (beforeTool) {
                     writeAssistantMessage(beforeTool);
                 }
@@ -4486,6 +4558,8 @@ export async function runAgentTurn(prompt, options = {}) {
                 }
                 const scopeForBatch = await loadScopeForSession(session.sessionId).catch(() => undefined);
                 const isParallelSafe = (c) => {
+                    if (mcpRuntime?.isParallelSafe(c.name))
+                        return true;
                     if (c.name === "pentest.recon" ||
                         c.name === "net.context" ||
                         c.name === "tool.batch" ||
@@ -5030,6 +5104,9 @@ export async function runAgentTurn(prompt, options = {}) {
         });
         throw error;
     }
+    finally {
+        mcpLease?.release();
+    }
 }
 /** Compatibility boundary for callers that consume visible assistant text. */
 export async function runAgentLoop(prompt, options = {}) {