@pentoshi/clai 3.11.6 → 3.11.8

package/dist/agent/runner.js

@@ -58,12 +58,13 @@ import { buildDurableEnvelope, WorkLedger, } from "./durable-envelope.js";
 import { COMPACTION_SYSTEM_PROMPT, } from "./compaction-summary.js";
 import { maybeAppendPlanModeReminder, PLAN_REMINDER_TOAST, } from "./plan-mode-reminders.js";
 import { LoopGuard } from "./loop-guard.js";
+import { appendInterruptedReasoning, interruptedReasoningBrief, isMeaningfulResumptionYield, } from "./interrupted-reasoning.js";
 import { CompactionAttemptLedger, compactionAttemptKey, } from "./compaction-attempt.js";
 import { resolveRequestBudget } from "./request-budget.js";
 import { loadPlan, mutatePlan, markTask, appendPlanTask, readyPlanTasks, foregroundRemaining, responderOpenTasks, isPlanTerminal, isPlanSuccessful, } from "../store/plan.js";
 import { stat } from "node:fs/promises";
 import { isOutsideWorkingDirectory, resolveFsToolPath, } from "../tools/fs.js";
-import { stripSentinelTokens, parseToolCall, recognizeBareToolJson, looksLikeTruncatedToolCall, salvageTruncatedWrite, salvageTruncatedWriteFromNative, countToolFences, parseAllToolCalls, groupToolCallsForExecution, buildTurnHistory, collapseRepeatedText, textBeforeToolCall, formatToolArgs, looksLikePentestTask, looksLikeBuildTask, looksLikeInformationalQuery, looksLikeIdleOrSocialPrompt, looksLikeActionNarration, looksLikeWebActionNarration, looksLikePlanNarration, looksLikeErrorDiagnosisWithFixIntent, localHttpProbeIsFailure, localHttpProbeIsSuccess, requiresFreshWebSearch, freshnessGuardMessage, buildWorkflowDirective, narrowNmapOperationDirective, pentestWorkflowDirective, pentestNoLocalServerDirective, shouldDimToolChatter, looksLikePromptLeak, } from "./tool-call-parser.js";
+import { stripSentinelTokens, parseToolCall, recognizeBareToolJson, looksLikeTruncatedToolCall, salvageTruncatedWrite, salvageTruncatedWriteFromNative, countToolFences, parseAllToolCalls, groupToolCallsForExecution, buildTurnHistory, collapseRepeatedText, textBeforeToolCall, formatToolArgs, looksLikePentestTask, looksLikeBuildTask, looksLikeInformationalQuery, looksLikeIdleOrSocialPrompt, looksLikeActionNarration, looksLikeWebActionNarration, localHttpProbeIsFailure, localHttpProbeIsSuccess, requiresFreshWebSearch, freshnessGuardMessage, buildWorkflowDirective, narrowNmapOperationDirective, pentestWorkflowDirective, pentestNoLocalServerDirective, shouldDimToolChatter, looksLikePromptLeak, } from "./tool-call-parser.js";
 import { createSessionPolicy, isPreApprovalAllowedTool, isPlanModeAllowedShellCommand, isPlanModeAllowedTool, isPlanApprovedByStatus, planHasOpenWork, isAbortError, shouldEnableImageOcr, } from "./session-policy.js";
 import { saveToolOutput, summarizeOutput, formatToolContext, } from "./tool-output-formatting.js";
 import { codingSessionFromContext, isProtocolPlaceholderOutput, progressPauseMode, } from "./progress-pause-policy.js";
@@ -74,7 +75,8 @@ import { absorbLooseWorkIntoLedger, applyDestinationCwd, canMarkTaskDone, hasLoc
 import { buildSessionStateBlock, inferNextHint, upsertSessionStateMessage, } from "./session-state.js";
 import { buildContinueOrientation, looksLikeContinueOrResumePrompt, } from "./continue-orient.js";
 import { detectPackageManager } from "./workspace-orient.js";
-import { budgetRemaining, consumeBudget, createRecoveryBudgets, freestyleClaimsAppReady, looksLikeShallowPentestReport, recoveryForErrorDiagnosis, recoveryForFailedProbe, recoveryForFreshness, recoveryForMissingFeature, recoveryForMissingPlan, recoveryForNarration, recoveryForPrematureComplete, recoveryForRuntimeVerify, recoveryForShallowPentest, } from "./must-continue.js";
+import { budgetRemaining, consumeBudget, createRecoveryBudgets, } from "./must-continue.js";
+import { chooseFinalizeRecovery } from "./finalize-gate.js";
 import { outOfScopeToolMessage, scopeContextMessage } from "./scope-context.js";
 import { EngagementPolicyEngine, actionFromUrl, engagementActionsForToolCall, evaluateEngagementAction, } from "../safety/engagement-policy.js";
 import { patchPlanMeta } from "../store/plan.js";
@@ -169,6 +171,8 @@ export async function runAgentTurn(prompt, options = {}) {
     // at the top of every loop iteration.
     let visibleCommitted = false;
     let interruptedVisible = "";
+    let interruptedReasoning = "";
+    let lowYieldResumptions = 0;
     const trimExactContinuationOverlap = (previous, current, minLength = 32) => {
         if (previous.length > 0 && current.startsWith(previous)) {
             return current.slice(previous.length);
@@ -540,6 +544,9 @@ export async function runAgentTurn(prompt, options = {}) {
         // Request, project, workspace, recovery, scope, and plan state are appended
         // later as system-marked turns so a changing byte cannot invalidate the
         // constitution (and, on Anthropic, the native tool schemas before it).
+        // The red-team methodology block is ~940 tokens on every request. Attach it
+        // only when this turn is actually a remote-security engagement.
+        const pentestPromptTurn = pentestLikeTurn || activePlan?.kind === "pentest";
         const buildStableSystemContent = (native) => {
             const reliability = getReliabilityPolicy();
             const visionAvailable = modelSupportsVision(provider, model);
@@ -551,6 +558,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 imageView: visionAvailable,
                 // E6: slim native constitution when API tool schemas are attached.
                 ...(native ? { slimNative: reliability.slimNativePrompt } : {}),
+                ...(pentestPromptTurn ? { pentest: true } : {}),
             });
         };
         const systemSections = [renderRequestEnvironmentContext()];
@@ -3095,6 +3103,30 @@ export async function runAgentTurn(prompt, options = {}) {
                 let accumulatedText = "";
                 const callIds = [];
                 let streamedCallsCount = 0;
+                // A model can think silently for minutes. Without a heartbeat the UI
+                // shows a frozen label and the turn looks hung, so surface elapsed time
+                // and the current phase on a timer rather than only on token arrival.
+                const streamStartedAt = Date.now();
+                const streamPhase = () => {
+                    const seconds = Math.round((Date.now() - streamStartedAt) / 1000);
+                    const elapsed = seconds < 60
+                        ? `${seconds}s`
+                        : `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, "0")}s`;
+                    if (generatedTokens > 0 && !inThinking) {
+                        return `generating response · ${generatedTokens} tokens · ${elapsed}`;
+                    }
+                    if (sawReasoning)
+                        return `thinking · ${elapsed}`;
+                    return `waiting for model · ${elapsed}`;
+                };
+                const heartbeat = setInterval(() => {
+                    const text = streamPhase();
+                    if (writesDirectly)
+                        spinner.setLabel(text);
+                    else
+                        emit({ type: "status", text });
+                }, 10_000);
+                heartbeat.unref?.();
                 const deferredToolCalls = [];
                 const deltaParser = writesDirectly
                     ? undefined
@@ -3336,6 +3368,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         resetStreamRecoveryState(recoveryState);
                         allowModelFallback = false;
                         preferModelFallback = false;
+                        lowYieldResumptions = 0;
                     }
                     catch (streamError) {
                         // User cancelled (double-Esc) — never try to recover, just stop.
@@ -3363,47 +3396,89 @@ export async function runAgentTurn(prompt, options = {}) {
                         // We only rethrow (stop the turn) in the worst case: every approach
                         // for that failure class is exhausted or the total budget is spent.
                         const failureKind = classifyStreamFailure(streamError);
+                        const partialStream = streamAlreadyEmitted(streamError) || accumulatedText.length > 0;
+                        const partial = rememberThinkingFromText(accumulatedText);
+                        const rawPartialVisible = partialStream
+                            ? textBeforeToolCall(stripThinking(collapseRepeatedText(accumulatedText)).visible)
+                            : "";
+                        const normalizedPartialVisible = trimExactContinuationOverlap(interruptedVisible, rawPartialVisible);
+                        const partialVisible = normalizedPartialVisible.trim();
+                        // A route that drops after a handful of characters is not making
+                        // progress, however many times it is retried. Only a substantial
+                        // yield unlocks the generous resumption budget; anything less is
+                        // charged to the failure class and escalates to another route.
+                        const meaningfulProgress = partialStream &&
+                            isMeaningfulResumptionYield(normalizedPartialVisible.length + partial.thinkContent.length);
+                        if (partialStream) {
+                            lowYieldResumptions = meaningfulProgress
+                                ? 0
+                                : lowYieldResumptions + 1;
+                        }
                         const plan = planStreamRecovery({
                             kind: failureKind,
                             state: recoveryState,
+                            progressed: meaningfulProgress,
                         });
-                        const partialStream = streamAlreadyEmitted(streamError) || accumulatedText.length > 0;
+                        const terminalFailure = plan.action === "give-up";
                         let continuationNudge = "";
                         if (partialStream) {
                             spinner.stop();
                             deltaParser?.finish();
-                            const partial = rememberThinkingFromText(accumulatedText);
                             const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
-                            const rawPartialVisible = textBeforeToolCall(stripThinking(collapseRepeatedText(accumulatedText)).visible);
-                            const normalizedPartialVisible = trimExactContinuationOverlap(interruptedVisible, rawPartialVisible);
-                            const partialVisible = normalizedPartialVisible.trim();
                             if (partialVisible) {
-                                writeAssistantMessage(partialVisible);
-                                pushAssistantHistory(partialVisible);
+                                // Finalizing here would close the streaming card and split one
+                                // answer across a card per interruption. Keep it open and let
+                                // the single commit below paint the stitched text; only a
+                                // terminal failure has to flush it now.
+                                if (terminalFailure) {
+                                    writeAssistantMessage(interruptedVisible + normalizedPartialVisible);
+                                }
+                                else {
+                                    visibleCommitted = true;
+                                }
+                                messages.push({
+                                    role: "assistant",
+                                    content: sanitizeAssistantText(partialVisible),
+                                });
                                 interruptedVisible += normalizedPartialVisible;
                             }
-                            else if (!writesDirectly) {
+                            else if (terminalFailure && !writesDirectly) {
                                 emit({ type: "assistant-message", text: "" });
                             }
                             if (partial.hasThinking && !hasShownToolCall) {
                                 writeThinkingBlock(partial.thinkContent);
                             }
+                            if (partial.hasThinking) {
+                                interruptedReasoning = appendInterruptedReasoning(interruptedReasoning, partial.thinkContent);
+                            }
                             for (const deferred of deferredToolCalls) {
                                 if (!deferred.shown || deferred.call.name === "…")
                                     continue;
                                 writeToolBlocked(deferred.eventId, deferred.call.name, "Incomplete tool call discarded after the provider stream was interrupted.", chalk.yellow("  ⚠ incomplete tool call discarded after stream interruption\n"));
                             }
-                            continuationNudge =
-                                "The provider stream was interrupted after partial output. Continue from the exact stopping point without repeating prior text. Any incomplete tool call was discarded and must be reissued in full.";
-                            const restartNotice = plan.action === "give-up"
+                            continuationNudge = [
+                                partialVisible
+                                    ? "The provider stream was interrupted after partial output. Continue from the exact stopping point without repeating prior text. Any incomplete tool call was discarded and must be reissued in full."
+                                    : "The provider stream was interrupted before any answer was produced. Any incomplete tool call was discarded and must be reissued in full. Do not restart your analysis from the beginning.",
+                                interruptedReasoningBrief(interruptedReasoning),
+                            ]
+                                .filter((part) => Boolean(part))
+                                .join("\n\n");
+                            const restartNotice = terminalFailure
                                 ? "partial response preserved before terminal provider failure"
-                                : "partial response preserved — resuming from the interruption";
+                                : lowYieldResumptions > 1
+                                    ? `route is dropping after almost no output (${lowYieldResumptions} in a row) — switching model`
+                                    : "partial response preserved — resuming from the interruption";
                             writeNotice("warn", restartNotice, chalk.yellow(`  ⚠ ${restartNotice}\n`));
                         }
-                        if (plan.action === "give-up") {
+                        if (terminalFailure) {
                             throw streamError;
                         }
-                        recordRecoveryAttempt(recoveryState, failureKind);
+                        recordRecoveryAttempt(recoveryState, failureKind, meaningfulProgress);
+                        if (lowYieldResumptions > 1) {
+                            allowModelFallback = true;
+                            preferModelFallback = true;
+                        }
                         if (plan.notice) {
                             writeNotice("warn", plan.notice, chalk.yellow(`  ⚠ ${plan.notice}\n`));
                         }
@@ -3434,6 +3509,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 }
                 finally {
                     // Always clear the spinner — abort, network error, or success.
+                    clearInterval(heartbeat);
                     spinner.stop();
                 }
                 if (responderDelivery) {
@@ -3487,7 +3563,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 const commitAssistantRetry = (historyText) => {
                     const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
                     if (!hasShownToolCall) {
-                        const displayText = textBeforeToolCall(collapseRepeatedText(assistantText.visible)).trim();
+                        const displayText = textBeforeToolCall(collapseRepeatedText(canonicalAssistantVisible)).trim();
                         if (displayText) {
                             writeAssistantMessage(displayText);
                         }
@@ -3503,6 +3579,8 @@ export async function runAgentTurn(prompt, options = {}) {
                     }
                     pushAssistantHistory(historyText);
                     interruptedVisible = "";
+                    interruptedReasoning = "";
+                    lowYieldResumptions = 0;
                 };
                 // Only emit a thinking-block event when the classic renderer is
                 // active (writesDirectly / no deltaParser).  In TUI v2 the
@@ -3949,182 +4027,61 @@ export async function runAgentTurn(prompt, options = {}) {
                             "If analysis is incomplete, call only the bounded evidence tool needed now. If each result has been analyzed and is satisfactory, you MUST call job.read with its jobId or exact notificationId before giving a final response. job.read does not require an active plan; do not create or update a plan merely to acknowledge a result."));
                         continue;
                     }
-                    const planNarrated = (buildLikeTurn || pentestLikeTurn) &&
-                        !activePlan &&
-                        looksLikePlanNarration(cleaned);
-                    // Only force "diagnosed but not fixed" when the model is still
-                    // narrating a fix without having applied one this turn. Post-fix
-                    // summaries ("I've fixed…", build passed) must never re-enter.
-                    const errorFixNarration = !sawSuccessfulMutation &&
-                        looksLikeErrorDiagnosisWithFixIntent(cleaned);
-                    const shouldRetryBeforeFinalizing = productiveSteps === 0 ||
-                        planNarrated ||
-                        ((narratedAction || narratedWebAction) && !informationalQuery) ||
-                        (session.planApproved.value &&
-                            planHasOpenWorkNow &&
-                            (narratedAction || errorFixNarration)) ||
-                        // errorFix only when no mutation yet (gate is in errorFixNarration)
-                        (session.planApproved.value && errorFixNarration) ||
-                        (buildLikeTurn && errorFixNarration);
-                    if (wantsAction &&
-                        cleaned.trim().length > 0 &&
-                        shouldRetryBeforeFinalizing) {
-                        let action;
-                        if (errorFixNarration && budgetRemaining(recovery, "errorFix")) {
-                            action = recoveryForErrorDiagnosis(toolsAttached);
-                        }
-                        else if (budgetRemaining(recovery, "actionIntent") &&
-                            planHasOpenWorkNow &&
-                            session.planApproved.value) {
-                            action = recoveryForNarration(toolsAttached, "plan_open");
-                        }
-                        else if (budgetRemaining(recovery, "actionIntent") &&
-                            pentestLikeTurn) {
-                            action = recoveryForNarration(toolsAttached, "pentest");
-                        }
-                        else if (budgetRemaining(recovery, "actionIntent") &&
-                            (freshWebSearchRequired || narratedWebAction)) {
-                            action = recoveryForNarration(toolsAttached, "web");
-                        }
-                        else if (budgetRemaining(recovery, "actionIntent") &&
-                            buildLikeTurn &&
-                            (planNarrated || productiveSteps > 0)) {
-                            action = recoveryForNarration(toolsAttached, "build_plan_prose");
-                        }
-                        else if (budgetRemaining(recovery, "actionIntent") &&
-                            buildLikeTurn) {
-                            action = recoveryForNarration(toolsAttached, "build");
-                        }
-                        else if (budgetRemaining(recovery, "actionIntent")) {
-                            action = recoveryForNarration(toolsAttached, "generic");
-                        }
-                        if (action) {
-                            consumeBudget(recovery, action.budgetKey);
-                            commitAssistantRetry(assistantText.visible);
-                            messages.push(recoveryUserMessage(action.message));
-                            continue;
-                        }
-                    }
-                    if (freshWebSearchRequired &&
-                        !sawFreshWebSearch &&
-                        budgetRemaining(recovery, "freshnessUsed")) {
-                        const action = recoveryForFreshness(freshnessGuardMessage() +
-                            (toolsAttached
-                                ? " Call the web_search tool now."
-                                : " Reply with ONLY a fenced ```tool block for web.search now."));
-                        consumeBudget(recovery, action.budgetKey);
-                        commitAssistantRetry(assistantText.visible);
-                        messages.push(recoveryUserMessage(action.message));
-                        continue;
-                    }
-                    if (isPlanMode &&
-                        !informationalQuery &&
-                        !idleOrSocialPrompt &&
-                        budgetRemaining(recovery, "forcePlan")) {
-                        const planAtEnd = await loadPlan(session.sessionId).catch(() => undefined);
-                        if (!planAtEnd && !sawPlanCreateOk) {
-                            const action = recoveryForMissingPlan(toolsAttached);
-                            consumeBudget(recovery, action.budgetKey);
-                            commitAssistantRetry(assistantText.visible);
-                            messages.push(recoveryUserMessage(action.message));
-                            continue;
-                        }
-                    }
-                    if (buildLike &&
-                        !pentestLike &&
-                        !pentestSession &&
-                        session.planApproved.value &&
-                        featureAppAsk &&
-                        !sawFeatureImplWrite &&
-                        (sawScaffoldOk || sawLocalAppMaterialWork) &&
-                        productiveSteps > 0 &&
-                        budgetRemaining(recovery, "featureImpl")) {
-                        const action = recoveryForMissingFeature(getActiveProjectRoot());
-                        consumeBudget(recovery, action.budgetKey);
-                        commitAssistantRetry(assistantText.visible);
-                        messages.push(recoveryUserMessage(action.message));
-                        continue;
-                    }
-                    if (buildLike &&
-                        !pentestLike &&
-                        !pentestSession &&
-                        budgetRemaining(recovery, "runtimeVerify") &&
-                        (!featureAppAsk || sawFeatureImplWrite)) {
-                        const runtimePlan = await loadPlan(session.sessionId).catch(() => undefined);
-                        // Durable plan evidence or multi-signal proof this turn is enough
-                        const planRuntimeOk = Boolean(runtimePlan && planHasVerifiedRuntime(runtimePlan));
-                        const sessionRuntimeOk = sawServerStart &&
-                            (sawServerTail || sawLocalHttpProbe || planRuntimeOk);
-                        if (!planRuntimeOk && !sessionRuntimeOk) {
-                            const codingPlanFinished = Boolean(runtimePlan &&
-                                session.planApproved.value &&
-                                runtimePlan.kind !== "pentest" &&
-                                runtimePlan.tasks.length > 0 &&
-                                runtimePlan.tasks.every((task) => task.state === "done" || task.state === "skipped"));
-                            const freestyleLocalAppDone = !session.planApproved.value &&
-                                sawLocalAppMaterialWork &&
-                                productiveSteps > 0 &&
-                                freestyleClaimsAppReady(cleaned) &&
-                                (getActiveProjectRoot() !== undefined ||
-                                    /\b(?:npm|pnpm|yarn|bun)\s+run\s+dev\b/i.test(cleaned) ||
-                                    /\bopen\s+http:\/\/localhost\b/i.test(cleaned));
-                            if (codingPlanFinished || freestyleLocalAppDone) {
-                                const action = recoveryForRuntimeVerify(getActiveProjectRoot());
-                                consumeBudget(recovery, action.budgetKey);
-                                commitAssistantRetry(assistantText.visible);
-                                messages.push(recoveryUserMessage(action.message));
-                                continue;
+                    const deferResponderReport = session.planApproved.value &&
+                        budgetRemaining(recovery, "prematureComplete")
+                        ? shouldYieldForDeclaredResponderDependency(livePlanAtCompletion, jobManager.getRunningJobs(session.sessionId), jobManager.getPendingNotifications(session.sessionId), responderWakeNotificationId)
+                        : false;
+                    const finalizeRecovery = chooseFinalizeRecovery({
+                        cleaned,
+                        recovery,
+                        toolsAttached,
+                        productiveSteps,
+                        planApproved: session.planApproved.value,
+                        planHasOpenWork: planHasOpenWorkNow,
+                        activePlanExists: Boolean(activePlan),
+                        wantsAction,
+                        narratedAction,
+                        narratedWebAction,
+                        isPlanMode,
+                        buildLikeTurn,
+                        pentestLikeTurn,
+                        buildLike,
+                        pentestLike,
+                        pentestSession,
+                        informationalQuery,
+                        idleOrSocialPrompt,
+                        freshWebSearchRequired,
+                        freshnessGuardText: freshWebSearchRequired
+                            ? freshnessGuardMessage()
+                            : "",
+                        sawFreshWebSearch,
+                        sawPlanCreateOk,
+                        sawFeatureImplWrite,
+                        sawScaffoldOk,
+                        sawLocalAppMaterialWork,
+                        sawServerStart,
+                        sawServerTail,
+                        sawLocalHttpProbe,
+                        sawFailedLocalHttpProbe,
+                        sawActivePentestTest,
+                        sawSuccessfulMutation,
+                        featureAppAsk,
+                        projectRoot: getActiveProjectRoot(),
+                        plan: livePlanAtCompletion
+                            ? {
+                                kind: livePlanAtCompletion.kind,
+                                hasVerifiedRuntime: planHasVerifiedRuntime(livePlanAtCompletion),
+                                tasks: livePlanAtCompletion.tasks,
                             }
-                        }
-                    }
-                    if (buildLike &&
-                        !pentestLike &&
-                        !pentestSession &&
-                        sawFailedLocalHttpProbe &&
-                        !sawLocalHttpProbe &&
-                        budgetRemaining(recovery, "failedProbe") &&
-                        cleaned.trim().length > 0) {
-                        const action = recoveryForFailedProbe();
-                        consumeBudget(recovery, action.budgetKey);
-                        commitAssistantRetry(assistantText.visible);
-                        messages.push(recoveryUserMessage(action.message));
-                        continue;
-                    }
-                    if ((pentestLike || pentestSession) &&
-                        budgetRemaining(recovery, "shallowPentest") &&
-                        looksLikeShallowPentestReport(cleaned, {
-                            productiveSteps,
-                            sawActiveTest: sawActivePentestTest,
-                        })) {
-                        const action = recoveryForShallowPentest();
-                        consumeBudget(recovery, action.budgetKey);
+                            : undefined,
+                        deferResponderReport,
+                    });
+                    if (finalizeRecovery) {
+                        consumeBudget(recovery, finalizeRecovery.budgetKey);
                         commitAssistantRetry(assistantText.visible);
-                        messages.push(recoveryUserMessage(action.message));
+                        messages.push(recoveryUserMessage(finalizeRecovery.message));
                         continue;
                     }
-                    if (session.planApproved.value &&
-                        budgetRemaining(recovery, "prematureComplete")) {
-                        const livePlan = await loadPlan(session.sessionId).catch(() => undefined);
-                        const unfinished = livePlan?.tasks.filter((task) => !task.responderOwned &&
-                            (task.state === "pending" || task.state === "in_progress"));
-                        const deferReport = shouldYieldForDeclaredResponderDependency(livePlan, jobManager.getRunningJobs(session.sessionId), jobManager.getPendingNotifications(session.sessionId), responderWakeNotificationId);
-                        if (livePlan &&
-                            unfinished &&
-                            unfinished.length > 0 &&
-                            !deferReport) {
-                            const next = unfinished[0];
-                            const action = recoveryForPrematureComplete({
-                                unfinished,
-                                next,
-                                pentest: livePlan.kind === "pentest" || pentestSession,
-                                errorFix: errorFixNarration,
-                            });
-                            consumeBudget(recovery, action.budgetKey);
-                            commitAssistantRetry(assistantText.visible);
-                            messages.push(recoveryUserMessage(action.message));
-                            continue;
-                        }
-                    }
                     let outcomeStatus = "succeeded";
                     const remainingCriteria = [];
                     if (session.planApproved.value) {
@@ -4186,6 +4143,8 @@ export async function runAgentTurn(prompt, options = {}) {
                     emit({ type: "assistant-message", text: "" });
                 }
                 interruptedVisible = "";
+                interruptedReasoning = "";
+                lowYieldResumptions = 0;
                 let bound = [];
                 if (nativeToolCalls.length) {
                     bound = nativeToolCalls.map((tc, index) => {