@pentoshi/clai 3.11.0 → 3.11.1

package/dist/agent/runner.js

@@ -4,7 +4,7 @@ import { completeWithProvider, streamWithProvider } from "../llm/router.js";
 import { streamAlreadyEmitted } from "../llm/stream-progress.js";
 import { classifyStreamFailure, planStreamRecovery, recordRecoveryAttempt, createStreamRecoveryState, resetStreamRecoveryState, } from "./stream-recovery.js";
 import { resolveToolDialect } from "../llm/capabilities.js";
-import { syntheticToolCallId, isTextOnlyModel, fromWireName, } from "../llm/tool-protocol.js";
+import { syntheticToolCallId, isTextOnlyModel, markTextOnlyModel, fromWireName, } from "../llm/tool-protocol.js";
 import { sanitizeAssistantText } from "../ui/ansi-box.js";
 import { randomUUID } from "node:crypto";
 import { jobManager, } from "../tools/jobs.js";
@@ -1154,6 +1154,7 @@ export async function runAgentTurn(prompt, options = {}) {
         // normal continuation is governed by evidence and resource deltas above.
         const maxIterations = Math.max(210, computeMaxIterations(stepBudget));
         let productiveSteps = 0;
+        let consecutiveModelOnlyRounds = 0;
         /** Successful file mutation this turn — kills false "error diagnosed but not fixed". */
         let sawSuccessfulMutation = false;
         let step = -1;
@@ -3137,7 +3138,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                             return;
                                         const name = fromWireName(delta.name) ?? delta.name;
                                         const existing = deferredToolCalls[delta.index];
-                                        if (existing) {
+                                        if (existing && existing.call.name !== "…") {
                                             if (delta.argumentsBytes &&
                                                 delta.argumentsBytes >= 4096 &&
                                                 !writesDirectly) {
@@ -3148,20 +3149,23 @@ export async function runAgentTurn(prompt, options = {}) {
                                             }
                                             return;
                                         }
-                                        // Ensure slots are dense so index maps to deferredToolCalls[i].
                                         while (deferredToolCalls.length < delta.index) {
+                                            const slot = deferredToolCalls.length;
+                                            const placeholderId = `tool-${++nextToolEventId}`;
+                                            callIds[slot] = placeholderId;
                                             deferredToolCalls.push({
-                                                eventId: `tool-${++nextToolEventId}`,
+                                                eventId: placeholderId,
                                                 call: { name: "…", args: {} },
                                                 rendered: "",
+                                                shown: false,
                                             });
                                         }
                                         const call = normalizeToolCall({
                                             name,
                                             args: {},
                                         });
-                                        const eventId = `tool-${++nextToolEventId}`;
-                                        callIds.push(eventId);
+                                        const eventId = existing?.eventId ?? `tool-${++nextToolEventId}`;
+                                        callIds[delta.index] = eventId;
                                         alreadyPrintedIds.add(eventId);
                                         const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
                                             chalk.gray(` ${formatToolArgs(call)}`);
@@ -3169,6 +3173,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                             eventId,
                                             call,
                                             rendered: styleToolChatter(call, toolCallLine) + "\n",
+                                            shown: false,
                                         };
                                         if (deferredToolCalls.length === delta.index) {
                                             deferredToolCalls.push(entry);
@@ -3178,6 +3183,8 @@ export async function runAgentTurn(prompt, options = {}) {
                                         }
                                         streamedCallsCount = Math.max(streamedCallsCount, deferredToolCalls.length);
                                         if (!writesDirectly) {
+                                            writeToolCall(eventId, call, entry.rendered);
+                                            entry.shown = true;
                                             emit({ type: "status", text: call.name });
                                         }
                                         else {
@@ -3202,16 +3209,20 @@ export async function runAgentTurn(prompt, options = {}) {
                                     while (streamedCallsCount < parsedCalls.length) {
                                         const call = parsedCalls[streamedCallsCount];
                                         const eventId = `tool-${++nextToolEventId}`;
-                                        callIds.push(eventId);
+                                        callIds[streamedCallsCount] = eventId;
                                         alreadyPrintedIds.add(eventId);
                                         const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
                                             chalk.gray(` ${formatToolArgs(call)}`);
-                                        deferredToolCalls.push({
+                                        const entry = {
                                             eventId,
                                             call,
                                             rendered: styleToolChatter(call, toolCallLine) + "\n",
-                                        });
+                                            shown: false,
+                                        };
+                                        deferredToolCalls.push(entry);
                                         if (!writesDirectly) {
+                                            writeToolCall(eventId, call, entry.rendered);
+                                            entry.shown = true;
                                             emit({ type: "status", text: call.name });
                                         }
                                         streamedCallsCount += 1;
@@ -3293,17 +3304,42 @@ export async function runAgentTurn(prompt, options = {}) {
                             kind: failureKind,
                             state: recoveryState,
                         });
+                        const partialStream = streamAlreadyEmitted(streamError) || accumulatedText.length > 0;
+                        let continuationNudge = "";
+                        if (partialStream) {
+                            spinner.stop();
+                            deltaParser?.finish();
+                            const partial = rememberThinkingFromText(accumulatedText);
+                            const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
+                            const partialVisible = textBeforeToolCall(stripThinking(collapseRepeatedText(accumulatedText)).visible).trim();
+                            if (partialVisible) {
+                                if (!hasShownToolCall) {
+                                    writeAssistantMessage(partialVisible);
+                                }
+                                pushAssistantHistory(partialVisible);
+                            }
+                            else if (!writesDirectly && !hasShownToolCall) {
+                                emit({ type: "assistant-message", text: partial.visible });
+                            }
+                            if (partial.hasThinking && !hasShownToolCall) {
+                                writeThinkingBlock(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"
+                                ? "partial response preserved before terminal provider failure"
+                                : "partial response preserved — resuming from the interruption";
+                            writeNotice("warn", restartNotice, chalk.yellow(`  ⚠ ${restartNotice}\n`));
+                        }
                         if (plan.action === "give-up") {
                             throw streamError;
                         }
                         recordRecoveryAttempt(recoveryState, failureKind);
-                        // The router refuses transparent retries after emission,
-                        // but the recovery ladder may still re-run the step. Say so, since
-                        // the visible answer restarts from scratch.
-                        if (streamAlreadyEmitted(streamError)) {
-                            const restartNotice = "partial answer discarded after a mid-stream failure — the reply restarts below";
-                            writeNotice("warn", restartNotice, chalk.yellow(`  ⚠ ${restartNotice}\n`));
-                        }
                         if (plan.notice) {
                             writeNotice("warn", plan.notice, chalk.yellow(`  ⚠ ${plan.notice}\n`));
                         }
@@ -3314,8 +3350,11 @@ export async function runAgentTurn(prompt, options = {}) {
                         if (plan.forceCompact) {
                             await maybeAutoCompact(`stream-recovery:${failureKind}`, true);
                         }
-                        if (plan.nudge) {
-                            messages.push(recoveryUserMessage(plan.nudge));
+                        const recoveryNudge = [continuationNudge, plan.nudge]
+                            .filter((part) => Boolean(part))
+                            .join("\n\n");
+                        if (recoveryNudge) {
+                            messages.push(recoveryUserMessage(recoveryNudge));
                         }
                         if (plan.delayMs > 0) {
                             emit({
@@ -3374,6 +3413,25 @@ export async function runAgentTurn(prompt, options = {}) {
                     (toolsAttached && !isTextOnlyModel(provider, model));
                 const assistantTextResult = rememberThinkingFromText(completion.text);
                 assistantText = assistantTextResult;
+                const commitAssistantRetry = (historyText) => {
+                    const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
+                    if (!hasShownToolCall) {
+                        const displayText = textBeforeToolCall(stripThinking(collapseRepeatedText(completion.text)).visible).trim();
+                        if (displayText) {
+                            writeAssistantMessage(displayText);
+                        }
+                        else if (deltaParser) {
+                            emit({ type: "assistant-message", text: "" });
+                        }
+                        if (assistantText.hasThinking && deltaParser) {
+                            emit({
+                                type: "thinking-block",
+                                content: assistantText.thinkContent,
+                            });
+                        }
+                    }
+                    pushAssistantHistory(historyText);
+                };
                 // Only emit a thinking-block event when the classic renderer is
                 // active (writesDirectly / no deltaParser).  In TUI v2 the
                 // deltaParser already streamed thinking-delta events that created
@@ -3392,13 +3450,14 @@ export async function runAgentTurn(prompt, options = {}) {
                 // otherwise create cards now (non-streaming / name-after-done providers).
                 if (nativeToolCalls.length) {
                     if (deferredToolCalls.length === 0) {
-                        for (const tc of nativeToolCalls) {
+                        for (let i = 0; i < nativeToolCalls.length; i += 1) {
+                            const tc = nativeToolCalls[i];
                             const normalized = normalizeToolCall({
                                 name: tc.name,
                                 args: tc.args,
                             });
                             const eventId = `tool-${++nextToolEventId}`;
-                            callIds.push(eventId);
+                            callIds[i] = eventId;
                             alreadyPrintedIds.add(eventId);
                             const toolCallLine = chalk.cyan(`  ▶ ${normalized.name}`) +
                                 chalk.gray(` ${formatToolArgs(normalized)}`);
@@ -3406,6 +3465,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 eventId,
                                 call: normalized,
                                 rendered: styleToolChatter(normalized, toolCallLine) + "\n",
+                                shown: false,
                             });
                         }
                     }
@@ -3418,6 +3478,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             });
                             const existing = deferredToolCalls[i];
                             if (existing && existing.call.name !== "…") {
+                                callIds[i] = existing.eventId;
                                 existing.call = normalized;
                                 const toolCallLine = chalk.cyan(`  ▶ ${normalized.name}`) +
                                     chalk.gray(` ${formatToolArgs(normalized)}`);
@@ -3426,16 +3487,15 @@ export async function runAgentTurn(prompt, options = {}) {
                             }
                             else if (!existing || existing.call.name === "…") {
                                 const eventId = existing?.eventId ?? `tool-${++nextToolEventId}`;
-                                if (!existing) {
-                                    callIds.push(eventId);
-                                    alreadyPrintedIds.add(eventId);
-                                }
+                                callIds[i] = eventId;
+                                alreadyPrintedIds.add(eventId);
                                 const toolCallLine = chalk.cyan(`  ▶ ${normalized.name}`) +
                                     chalk.gray(` ${formatToolArgs(normalized)}`);
                                 const entry = {
                                     eventId,
                                     call: normalized,
                                     rendered: styleToolChatter(normalized, toolCallLine) + "\n",
+                                    shown: existing?.shown ?? false,
                                 };
                                 if (existing)
                                     deferredToolCalls[i] = entry;
@@ -3551,7 +3611,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                         if (assistantText.hasThinking)
                             retryWithoutThinking = true;
-                        pushAssistantHistory(stripThinking(collapseRepeatedText(completion.text)).visible);
+                        commitAssistantRetry(stripThinking(collapseRepeatedText(completion.text)).visible);
                         // Keep nudges SHORT — cheap models lose the key instruction in long text.
                         const buildNudge = freshWebSearchRequired && !sawFreshWebSearch
                             ? toolsAttached
@@ -3603,6 +3663,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     }
                 }
                 if (!call) {
+                    consecutiveModelOnlyRounds += 1;
                     if (bareArgsOnly) {
                         bareToolJsonRetries += 1;
                         if (bareToolJsonRetries <= 3) {
@@ -3611,7 +3672,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 : "tool call missing its name/fence — asking the model to re-emit a proper ```tool block", chalk.yellow(toolsAttached
                                 ? "  ⚠ tool call missing its name — asking the model to call a tool properly\n"
                                 : "  ⚠ tool call missing its name/fence — asking the model to re-emit a proper ```tool block\n"));
-                            pushAssistantHistory(assistantText.visible);
+                            commitAssistantRetry(assistantText.visible);
                             messages.push(recoveryUserMessage(isPlanMode && !activePlan
                                 ? toolsAttached
                                     ? "Your previous message was a bare JSON args object with no tool name, so NOTHING ran. " +
@@ -3634,7 +3695,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     }
                     if (/<\|tool_call(?:s_section)?_begin\|>|<\|tool_call_argument_begin\|>/i.test(assistantText.visible)) {
                         writeNotice("warn", "tool call was malformed or cut off — asking the model to retry in JSON form", chalk.yellow("  ⚠ tool call was malformed or cut off — asking the model to retry in JSON form\n"));
-                        pushAssistantHistory(assistantText.visible);
+                        commitAssistantRetry(assistantText.visible);
                         messages.push(recoveryUserMessage(toolsAttached
                             ? "Your previous tool call was malformed or truncated. " +
                                 toolNudge(true) +
@@ -3656,7 +3717,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 if (writeResult.ok) {
                                     const lineCount = salvaged.content.split("\n").length;
                                     writeNotice("info", `tool call was truncated — salvaged ${lineCount} lines and wrote to ${salvaged.path}`, chalk.cyan(`  ℹ tool call was truncated — salvaged ${lineCount} lines to ${salvaged.path}\n`));
-                                    pushAssistantHistory(stripThinking(assistantText.visible).visible);
+                                    commitAssistantRetry(stripThinking(assistantText.visible).visible);
                                     const priorBytes = writeResult.bytesOnDisk;
                                     const salvagedToolName = salvaged.operation === "append" ? "fs.append" : "fs.write";
                                     messages.push({
@@ -3685,7 +3746,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                         if (truncatedToolRetries <= 3) {
                             writeNotice("warn", "tool call was cut off (output too long) — asking the model to retry safely", chalk.yellow("  ⚠ tool call was cut off (output too long) — asking the model to retry safely\n"));
-                            pushAssistantHistory(stripThinking(assistantText.visible).visible);
+                            commitAssistantRetry(stripThinking(assistantText.visible).visible);
                             messages.push({
                                 role: "user",
                                 content: toolsAttached
@@ -3718,7 +3779,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 if (writeResult.ok) {
                                     const lineCount = salvaged.content.split("\n").length;
                                     writeNotice("info", `malformed tool call salvaged — wrote ${lineCount} lines to ${salvaged.path}`, chalk.cyan(`  ℹ malformed tool call salvaged — wrote ${lineCount} lines to ${salvaged.path}\n`));
-                                    pushAssistantHistory(stripThinking(assistantText.visible).visible);
+                                    commitAssistantRetry(stripThinking(assistantText.visible).visible);
                                     messages.push({
                                         role: "user",
                                         content: `The system extracted and wrote ${lineCount} lines to ${salvaged.path} from your malformed tool call. ` +
@@ -3736,7 +3797,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         malformedFenceRetries += 1;
                         if (malformedFenceRetries <= 3) {
                             writeNotice("warn", "tool block present but its JSON didn't parse — asking the model to re-emit valid JSON", chalk.yellow("  ⚠ tool block present but its JSON didn't parse — asking the model to re-emit valid JSON\n"));
-                            pushAssistantHistory(stripThinking(assistantText.visible).visible);
+                            commitAssistantRetry(stripThinking(assistantText.visible).visible);
                             messages.push({
                                 role: "user",
                                 content: toolsAttached
@@ -3756,14 +3817,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                         // Exhausted retries — fall through to the normal path.
                     }
-                    const cleaned = stripSentinelTokens(assistantText.visible);
-                    if (unreadResponderNotificationIds.size > 0) {
-                        const unread = [...unreadResponderNotificationIds];
-                        pushAssistantHistory(assistantText.visible);
-                        messages.push(recoveryUserMessage(`You have ${unread.length} delivered Responder result(s) that remain unread: ${unread.join(", ")}. ` +
-                            "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 cleaned = collapseRepeatedText(stripSentinelTokens(assistantText.visible));
                     const narratedAction = looksLikeActionNarration(cleaned);
                     const narratedWebAction = looksLikeWebActionNarration(cleaned);
                     const reconciledPlanAtCompletion = await reconcileOpenTaskBeforeFinalizing();
@@ -3778,11 +3832,47 @@ export async function runAgentTurn(prompt, options = {}) {
                         (!informationalQuery &&
                             !idleOrSocialPrompt &&
                             (buildLikeTurn || pentestLikeTurn));
+                    const unreadResponderResults = unreadResponderNotificationIds.size > 0;
                     const wantsAction = !completedPlanDuringThisTurn &&
                         !idleOrSocialPrompt &&
                         (userExpectsWork ||
                             (narratedAction && !informationalQuery) ||
                             (narratedWebAction && !informationalQuery));
+                    if ((wantsAction || unreadResponderResults) &&
+                        toolsAttached &&
+                        consecutiveModelOnlyRounds === 2) {
+                        markTextOnlyModel(provider, model);
+                        commitAssistantRetry(assistantText.visible);
+                        writeNotice("warn", "model repeatedly returned prose instead of a native tool call — switching this model to the text tool protocol", chalk.yellow("  ⚠ switching this model to the text tool protocol after repeated non-actionable responses\n"));
+                        messages.push(recoveryUserMessage("Native tool calling did not produce an executable call. Continue now with exactly one complete fenced ```tool block. Do not repeat the prior narration."));
+                        continue;
+                    }
+                    if ((wantsAction || unreadResponderResults) &&
+                        consecutiveModelOnlyRounds >= 6) {
+                        commitAssistantRetry(assistantText.visible);
+                        const stalledMessage = "Stopped a repeated model-only retry cycle after the model returned no executable tool call. Completed work and transcript output were preserved.";
+                        writeAssistantMessage(stalledMessage);
+                        const remainingCriteria = livePlanAtCompletion
+                            ? foregroundRemaining(livePlanAtCompletion).map((task) => `[${task.id}] ${task.title}`)
+                            : [];
+                        if (unreadResponderResults) {
+                            remainingCriteria.push("Analyze and acknowledge each delivered Responder result.");
+                        }
+                        if (remainingCriteria.length === 0) {
+                            remainingCriteria.push("Continue the unfinished work with an executable tool call.");
+                        }
+                        outcomeState.outcome.status = "partial";
+                        await saveOutcomeState(outcomeState);
+                        moveTurn("partial", "repeated model-only responses");
+                        return finishTurn(stalledMessage, productiveSteps, "partial", remainingCriteria, "The model returned six consecutive responses without executing a tool.");
+                    }
+                    if (unreadResponderResults) {
+                        const unread = [...unreadResponderNotificationIds];
+                        commitAssistantRetry(assistantText.visible);
+                        messages.push(recoveryUserMessage(`You have ${unread.length} delivered Responder result(s) that remain unread: ${unread.join(", ")}. ` +
+                            "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);
@@ -3834,7 +3924,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                         if (action) {
                             consumeBudget(recovery, action.budgetKey);
-                            pushAssistantHistory(assistantText.visible);
+                            commitAssistantRetry(assistantText.visible);
                             messages.push(recoveryUserMessage(action.message));
                             continue;
                         }
@@ -3847,7 +3937,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 ? " Call the web_search tool now."
                                 : " Reply with ONLY a fenced ```tool block for web.search now."));
                         consumeBudget(recovery, action.budgetKey);
-                        pushAssistantHistory(assistantText.visible);
+                        commitAssistantRetry(assistantText.visible);
                         messages.push(recoveryUserMessage(action.message));
                         continue;
                     }
@@ -3859,7 +3949,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         if (!planAtEnd && !sawPlanCreateOk) {
                             const action = recoveryForMissingPlan(toolsAttached);
                             consumeBudget(recovery, action.budgetKey);
-                            pushAssistantHistory(assistantText.visible);
+                            commitAssistantRetry(assistantText.visible);
                             messages.push(recoveryUserMessage(action.message));
                             continue;
                         }
@@ -3875,7 +3965,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         budgetRemaining(recovery, "featureImpl")) {
                         const action = recoveryForMissingFeature(getActiveProjectRoot());
                         consumeBudget(recovery, action.budgetKey);
-                        pushAssistantHistory(assistantText.visible);
+                        commitAssistantRetry(assistantText.visible);
                         messages.push(recoveryUserMessage(action.message));
                         continue;
                     }
@@ -3905,7 +3995,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             if (codingPlanFinished || freestyleLocalAppDone) {
                                 const action = recoveryForRuntimeVerify(getActiveProjectRoot());
                                 consumeBudget(recovery, action.budgetKey);
-                                pushAssistantHistory(assistantText.visible);
+                                commitAssistantRetry(assistantText.visible);
                                 messages.push(recoveryUserMessage(action.message));
                                 continue;
                             }
@@ -3920,7 +4010,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         cleaned.trim().length > 0) {
                         const action = recoveryForFailedProbe();
                         consumeBudget(recovery, action.budgetKey);
-                        pushAssistantHistory(assistantText.visible);
+                        commitAssistantRetry(assistantText.visible);
                         messages.push(recoveryUserMessage(action.message));
                         continue;
                     }
@@ -3932,7 +4022,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         })) {
                         const action = recoveryForShallowPentest();
                         consumeBudget(recovery, action.budgetKey);
-                        pushAssistantHistory(assistantText.visible);
+                        commitAssistantRetry(assistantText.visible);
                         messages.push(recoveryUserMessage(action.message));
                         continue;
                     }
@@ -3954,7 +4044,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 errorFix: errorFixNarration,
                             });
                             consumeBudget(recovery, action.budgetKey);
-                            pushAssistantHistory(assistantText.visible);
+                            commitAssistantRetry(assistantText.visible);
                             messages.push(recoveryUserMessage(action.message));
                             continue;
                         }
@@ -3999,6 +4089,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         outcomeStatus,
                         remainingCriteria,
                     });
+                    writeAssistantMessage(cleaned);
                     lastAnswer = cleaned;
                     return finishTurn(lastAnswer, step + 1, outcomeStatus, remainingCriteria, outcomeStatus === "failed"
                         ? "One or more required plan tasks failed."
@@ -4013,7 +4104,8 @@ export async function runAgentTurn(prompt, options = {}) {
                     : nativeToolCalls.length
                         ? assistantText.visible.trim()
                         : textBeforeToolCall(assistantText.visible);
-                if (beforeTool) {
+                if (beforeTool &&
+                    !deferredToolCalls.some((entry) => entry.shown)) {
                     writeAssistantMessage(beforeTool);
                 }
                 let bound = [];
@@ -4182,7 +4274,10 @@ export async function runAgentTurn(prompt, options = {}) {
                 for (const deferred of activeDeferredToolCalls.slice(0, allCalls.length)) {
                     if (!deferred.call.name || deferred.call.name === "…")
                         continue;
-                    writeToolCall(deferred.eventId, deferred.call, deferred.rendered);
+                    if (!deferred.shown || !writesDirectly) {
+                        writeToolCall(deferred.eventId, deferred.call, deferred.rendered);
+                        deferred.shown = true;
+                    }
                 }
                 if (historyNativeCalls.length) {
                     appendAssistantWithTools(messages, beforeTool ?? "", historyNativeCalls, completion.reasoningBlock);
@@ -4232,6 +4327,7 @@ export async function runAgentTurn(prompt, options = {}) {
                  * explicit user abort stops remaining calls.
                  */
                 const recordResult = (boundCall, res) => {
+                    consecutiveModelOnlyRounds = 0;
                     recordedNativeIds.add(boundCall.id);
                     actionSequenceExecuted += 1;
                     // A policy-suppressed call is deterministic: replaying it verbatim