@ouro.bot/cli 0.1.0-alpha.806 → 0.1.0-alpha.808

package/dist/heart/core.js

@@ -553,11 +553,6 @@ function messageContentText(content) {
         .filter(Boolean)
         .join("\n");
 }
-function isHarnessCorrectiveUserText(text) {
-    return text.startsWith("no tool was called this turn. you must end every turn")
-        || text.startsWith("private-return acknowledgement claimed work was queued, but no ponder packet was created this turn.")
-        || text.startsWith("this exact request previously reached a tool that is advertised again now.");
-}
 function toolResultIndicatesFailure(content) {
     const normalized = content.trim().toLowerCase();
     return normalized.startsWith("error:")
@@ -598,7 +593,7 @@ function historicalFailedEffectsForExactRepeatedRequest(messages) {
         if (message?.role !== "user")
             continue;
         const text = messageContentText(message.content).replace(/\s+/g, " ").trim();
-        if (!text || isHarnessCorrectiveUserText(text))
+        if (!text)
             continue;
         userRequests.push({ index, text });
     }
@@ -643,8 +638,6 @@ function latestUserMessageText(messages) {
         if (message?.role !== "user")
             continue;
         const text = messageContentText(message.content).trim();
-        if (isHarnessCorrectiveUserText(text))
-            continue;
         if (text.length > 0)
             return text;
     }
@@ -960,9 +953,15 @@ function buildAuthFailureGuidance(provider, model, agentName, detail) {
 }
 async function runAgent(messages, callbacks, channel, signal, options) {
     const generatedMessages = [];
+    let nextAttemptControls = [];
+    let rejectedAttempt = [];
     const pushGenerated = (...next) => {
         messages.push(...next);
         generatedMessages.push(...structuredClone(next));
+        if (rejectedAttempt.length > 0) {
+            rejectedAttempt = [];
+            providerRuntime.resetTurnState(messages);
+        }
     };
     const facing = (0, friends_1.channelToFacing)(channel);
     let providerRuntime = options?.providerRuntimeOverride ?? await getProviderRuntime(facing);
@@ -1127,10 +1126,14 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let providerIterations = 0;
     const requiredToolCallNames = [...new Set(options?.requiredToolCalls?.names ?? [])];
     const dispatchedRequiredToolCalls = new Set();
-    const requiredCorrectionMarker = Symbol("requiredCorrection");
-    const messagesWithoutRequiredCorrections = () => messages.filter((message) => message[requiredCorrectionMarker] !== true);
-    const removeRequiredCorrections = () => {
-        messages.splice(0, messages.length, ...messagesWithoutRequiredCorrections());
+    const rejectAttempt = (assistant, controls) => {
+        rejectedAttempt = [structuredClone(assistant)];
+        nextAttemptControls = controls;
+    };
+    const rejectToolBatch = (assistant, reasons) => {
+        rejectAttempt(assistant, assistant.tool_calls.map((call, index) => ({
+            role: "tool", tool_call_id: call.id, content: reasons[index],
+        })));
     };
     const pendingRequiredToolCalls = () => {
         const missing = requiredToolCallNames.filter((name) => !dispatchedRequiredToolCalls.has(name));
@@ -1138,16 +1141,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             ? { missing, message: `${options.requiredToolCalls.retryMessage} Missing required tool calls: ${missing.join(", ")}.` }
             : null;
     };
-    const queueRequiredCorrection = (message, limitContext) => {
+    const queueRequiredCorrection = (assistant, message, limitContext) => {
         if (providerIterations >= exports.MAX_PROVIDER_ITERATIONS)
             throw new Error(`provider iteration limit exhausted at response ${exports.MAX_PROVIDER_ITERATIONS} ${limitContext}`);
-        const correction = {
-            role: "user",
-            content: message,
-            [requiredCorrectionMarker]: true,
-        };
-        messages.push(correction);
-        providerRuntime.resetTurnState(messages);
+        rejectAttempt(assistant, [{ role: "user", content: message }]);
     };
     const toolLoopState = (0, tool_loop_1.createToolLoopState)();
     const toolFrictionLedger = (0, tool_friction_1.createToolFrictionLedger)();
@@ -1180,8 +1177,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 summary: (0, error_classification_1.summarizeProviderError)(terminalError, terminalErrorClassification, providerRuntime.id, providerRuntime.model),
             },
         });
-        stripLastToolCalls(messages);
-        stripLastToolCalls(generatedMessages);
+        // Only legacy input can still contain unaccepted calls. Generated output
+        // has crossed acceptance; a later provider failure cannot revoke effects.
+        if (generatedMessages.length === 0)
+            stripLastToolCalls(messages);
         outcome = "errored";
         done = true;
     };
@@ -1304,6 +1303,23 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 break;
             }
             try {
+                const budgetOptions = {
+                    requiredPromptEvidence: options?.requiredPromptEvidence,
+                    provider: providerRuntime.id,
+                    model: providerRuntime.model,
+                    contextWindowTokens: (0, config_1.getContextConfig)().maxTokens,
+                };
+                const canonicalBudget = (0, prompt_budget_1.applyPromptBudget)({ ...budgetOptions, messages });
+                if (canonicalBudget.status !== "within_budget") {
+                    messages.splice(0, messages.length, ...canonicalBudget.messages);
+                }
+                // Preserve canonical evidence object identity while freezing the array
+                // and the one attempt's private control/scratch across operational retries.
+                const attemptMessages = rejectedAttempt.length > 0
+                    ? [...(0, prompt_budget_1.applyPromptBudget)({ ...budgetOptions, messages: [...messages, ...rejectedAttempt, ...nextAttemptControls] }).messages]
+                    : [...messages];
+                if (rejectedAttempt.length > 0 || canonicalBudget.status !== "within_budget")
+                    providerRuntime.resetTurnState(attemptMessages);
                 const turnCallbackBufferRef = { current: null };
                 const callProviderTurn = async () => {
                     callbacks.onModelStart();
@@ -1313,19 +1329,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             ? createFinalOnlyTextBuffer(callbacks)
                             : null;
                     try {
-                        const promptBudget = (0, prompt_budget_1.applyPromptBudget)({
-                            messages,
-                            requiredPromptEvidence: options?.requiredPromptEvidence,
-                            provider: providerRuntime.id,
-                            model: providerRuntime.model,
-                            contextWindowTokens: (0, config_1.getContextConfig)().maxTokens,
-                        });
-                        if (promptBudget.status !== "within_budget") {
-                            messages.splice(0, messages.length, ...promptBudget.messages);
-                            providerRuntime.resetTurnState(messages);
-                        }
                         return await providerRuntime.streamTurn({
-                            messages,
+                            messages: attemptMessages,
                             activeTools,
                             callbacks: turnCallbackBufferRef.current?.callbacks ?? callbacks,
                             signal,
@@ -1353,10 +1358,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             throw error;
                         if (isContextOverflow(error) && !overflowRetried) {
                             overflowRetried = true;
-                            stripLastToolCalls(messages);
-                            stripLastToolCalls(generatedMessages);
+                            const overflowMessages = messages.map((message) => message.role === "assistant" ? { ...message } : message);
+                            stripLastToolCalls(overflowMessages);
                             const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
-                            const trimmed = (0, context_1.trimMessages)(messages, maxTokens, contextMargin, maxTokens * 2);
+                            const trimmed = (0, context_1.trimMessages)(overflowMessages, maxTokens, contextMargin, maxTokens * 2);
                             const requiredEvidence = options?.requiredPromptEvidence;
                             const requiredMessages = new Set([
                                 ...(requiredEvidence?.verifiedPredecessorMessage ? [requiredEvidence.verifiedPredecessorMessage] : []),
@@ -1365,9 +1370,9 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             const trimmedMessages = new Set(trimmed);
                             const overflowRetryMessages = requiredMessages.size === 0
                                 ? trimmed
-                                : messages.filter((message) => trimmedMessages.has(message) || requiredMessages.has(message));
+                                : overflowMessages.filter((message) => trimmedMessages.has(message) || requiredMessages.has(message));
                             messages.splice(0, messages.length, ...overflowRetryMessages);
-                            providerRuntime.resetTurnState(messages);
+                            providerRuntime.resetTurnState(attemptMessages);
                             callbacks.onError(new Error("context trimmed, retrying..."), "transient");
                             return callProviderTurn();
                         }
@@ -1397,7 +1402,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             });
                             _providerRuntimeFactories[facing] = null;
                             providerRuntime = await getProviderRuntime(facing);
-                            providerRuntime.resetTurnState(messages);
+                            providerRuntime.resetTurnState(attemptMessages);
                         }
                         catch (refreshError) {
                             (0, runtime_1.emitNervesEvent)({
@@ -1412,7 +1417,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     },
                     sleep: async (delayMs) => {
                         await waitForProviderRetry(delayMs, signal);
-                        providerRuntime.resetTurnState(messages);
+                        providerRuntime.resetTurnState(attemptMessages);
                     },
                 });
                 if (!attempt.ok) {
@@ -1420,6 +1425,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     continue;
                 }
                 const result = attempt.value;
+                nextAttemptControls = [];
                 providerIterations += 1;
                 if (providerIterations === exports.MAX_PROVIDER_ITERATIONS && result.toolCalls.length > 0) {
                     throw new Error(`provider iteration limit exhausted at response ${exports.MAX_PROVIDER_ITERATIONS} before tool execution`);
@@ -1526,8 +1532,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                                 message: "unresolved historical effect exhausted deterministic tool-call retries; failing closed",
                                 meta: { provider: providerRuntime.id, model: providerRuntime.model, toolNames: retryableHistoricalTools, cap: NO_TOOL_CALL_MAX_RETRIES },
                             });
-                            msg.content = blockedAnswer;
-                            pushGenerated(msg);
+                            pushGenerated({ role: "assistant", content: blockedAnswer });
                             callbacks.onTextChunk(blockedAnswer);
                             completion = { answer: blockedAnswer, intent: "blocked" };
                             outcome = "blocked";
@@ -1548,18 +1553,17 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                                 cap: NO_TOOL_CALL_MAX_RETRIES,
                             },
                         });
-                        pushGenerated(msg);
-                        messages.push({
-                            role: "user",
-                            content: `this exact request previously reached a tool that is advertised again now. Its unresolved historical effect is through ${retryableHistoricalTools.join(", ")}. Only that tool is available now. Read current state if needed, then retry the exact failed effect. Do not report completion until the effect succeeds.`,
-                        });
+                        rejectAttempt(msg, [{
+                                role: "user",
+                                content: `this exact request previously reached a tool that is advertised again now. Its unresolved historical effect is through ${retryableHistoricalTools.join(", ")}. Only that tool is available now. Read current state if needed, then retry the exact failed effect. Do not report completion until the effect succeeds.`,
+                            }]);
                         continue;
                     }
                     const requiredToolCallsGate = pendingRequiredToolCalls();
                     if (requiredToolCallsGate) {
                         streamCallbackBuffer?.discard();
                         callbacks.onClearText?.();
-                        queueRequiredCorrection(requiredToolCallsGate.message, "before required tool calls completed");
+                        queueRequiredCorrection(msg, requiredToolCallsGate.message, "before required tool calls completed");
                         (0, runtime_1.emitNervesEvent)({
                             level: "warn",
                             component: "engine",
@@ -1573,7 +1577,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     if (requiredAnswerRejection) {
                         streamCallbackBuffer?.discard();
                         callbacks.onClearText?.();
-                        queueRequiredCorrection(requiredAnswerRejection, "before required terminal answer validation completed");
+                        queueRequiredCorrection(msg, requiredAnswerRejection, "before required terminal answer validation completed");
                         (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.required_tool_answer_rejected", message: "unsupported terminal answer rejected after required reads", meta: { answerLength: String(msg.content ?? "").length } });
                         continue;
                     }
@@ -1596,11 +1600,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                                     contentLength: result.content.length,
                                 },
                             });
-                            pushGenerated(msg);
-                            messages.push({
-                                role: "user",
-                                content: `${privateReturnTextAckRetryError} Emit the ponder(action=create, ...) tool call now, or ask a blocking clarification without saying the private work is queued.`,
-                            });
+                            rejectAttempt(msg, [{
+                                    role: "user",
+                                    content: `${privateReturnTextAckRetryError} Emit the ponder(action=create, ...) tool call now, or ask a blocking clarification without saying the private work is queued.`,
+                                }]);
                             continue;
                         }
                         const blockedAnswer = "I could not start the private pass. No private-attention packet was created, so no return work was queued.";
@@ -1616,8 +1619,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                                 contentLength: result.content.length,
                             },
                         });
-                        msg.content = blockedAnswer;
-                        pushGenerated(msg);
+                        pushGenerated({ role: "assistant", content: blockedAnswer });
                         callbacks.onTextChunk(blockedAnswer);
                         completion = { answer: blockedAnswer, intent: "blocked" };
                         outcome = "blocked";
@@ -1645,15 +1647,14 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                                 contentLength: result.content.length,
                             },
                         });
-                        pushGenerated(msg);
-                        messages.push({
-                            role: "user",
-                            content: isPrivateRuntimeChannel
-                                ? augmentedToolContext?.noSend === true
-                                    ? "no tool was called this turn. this is an immutable no-send turn; call rest now without creating a continuation."
-                                    : "no tool was called this turn. you must end every turn by calling rest (or surface, ponder, observe). emit the tool call now."
-                                : "no tool was called this turn. you must end every turn by calling settle with your answer (or ponder/observe). emit the tool call now.",
-                        });
+                        rejectAttempt(msg, [{
+                                role: "user",
+                                content: isPrivateRuntimeChannel
+                                    ? augmentedToolContext?.noSend === true
+                                        ? "no tool was called this turn. this is an immutable no-send turn; call rest now without creating a continuation."
+                                        : "no tool was called this turn. you must end every turn by calling rest (or surface, ponder, observe). emit the tool call now."
+                                    : "no tool was called this turn. you must end every turn by calling settle with your answer (or ponder/observe). emit the tool call now.",
+                            }]);
                         continue;
                     }
                     // Legitimate text-only response, or cap reached — accept as-is.
@@ -1664,20 +1665,19 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 else {
                     // Reset the retry counter on any successful tool call.
                     noToolCallRetries = 0;
-                    const preCallMessages = structuredClone(messagesWithoutRequiredCorrections().filter((message) => message.role !== "system"));
+                    const preCallMessages = structuredClone(messages.filter((message) => message.role !== "system"));
                     const validatedCalls = validateToolCallBatchAtProductionBoundary(result.toolCalls, activeTools);
                     const invalidCall = validatedCalls.find((entry) => "error" in entry);
                     if (invalidCall) {
-                        await streamCallbackBuffer?.flush();
-                        pushGenerated(msg);
+                        streamCallbackBuffer?.discard();
                         const unadvertisedCall = validatedCalls.find((entry) => !activeToolNames.has(entry.call.name));
+                        const rejections = [];
                         for (const entry of validatedCalls) {
                             const detail = "error" in entry ? entry.error : "another call in this batch had invalid arguments";
                             const rejection = unadvertisedCall
                                 ? `rejected: ${entry.call.name} was not advertised for this channel; no handler was executed.`
                                 : `invalid tool arguments: ${detail}`;
-                            pushGenerated({ role: "tool", tool_call_id: entry.call.id, content: rejection });
-                            providerRuntime.appendToolOutput(entry.call.id, rejection);
+                            rejections.push(rejection);
                             options?.toolBoundaryObserver?.({
                                 name: entry.call.name,
                                 reason: activeToolNames.has(entry.call.name) ? "invalid_arguments" : "profile_excluded",
@@ -1686,6 +1686,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                                 sideEffect: false,
                             });
                         }
+                        rejectToolBatch(msg, rejections);
                         if (unadvertisedCall) {
                             (0, runtime_1.emitNervesEvent)({
                                 level: "warn",
@@ -1715,12 +1716,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     if (habitBlockReason) {
                         streamCallbackBuffer?.discard();
                         recordBlockedHabitSurfaceAttempts(habitSession, result.toolCalls, habitBlockReason);
-                        pushGenerated(msg);
                         const blockedOutput = `blocked: ${habitBlockReason}. No tool side effects from this assistant message were executed.`;
-                        for (const call of result.toolCalls) {
-                            pushGenerated({ role: "tool", tool_call_id: call.id, content: blockedOutput });
-                            providerRuntime.appendToolOutput(call.id, blockedOutput);
-                        }
+                        rejectToolBatch(msg, result.toolCalls.map(() => blockedOutput));
                         (0, runtime_1.emitNervesEvent)({
                             level: "warn",
                             component: "engine",
@@ -1730,6 +1727,15 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         });
                         continue;
                     }
+                    const soleViolation = result.toolCalls.length > 1
+                        ? result.toolCalls.find((call) => SOLE_CALL_REJECTION[call.name] !== undefined || (0, tools_1.resolveToolDefinition)(call.name)?.terminalProjection?.requiresSoleCall === true)
+                        : undefined;
+                    if (soleViolation) {
+                        streamCallbackBuffer?.discard();
+                        const reason = SOLE_CALL_REJECTION[soleViolation.name] ?? `rejected: ${soleViolation.name} must be the only tool call.`;
+                        rejectToolBatch(msg, result.toolCalls.map(() => reason));
+                        continue;
+                    }
                     const soleTerminalCall = result.toolCalls.length === 1
                         ? result.toolCalls[0]
                         : null;
@@ -1784,7 +1790,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             streamCallbackBuffer?.discard();
                             callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
                             callbacks.onClearText?.();
-                            queueRequiredCorrection(requiredToolCallsGate.message, "before required tool calls completed");
+                            queueRequiredCorrection(msg, requiredToolCallsGate.message, "before required tool calls completed");
                             (0, runtime_1.emitNervesEvent)({
                                 level: "warn",
                                 component: "engine",
@@ -1800,10 +1806,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             streamCallbackBuffer?.discard();
                             callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
                             callbacks.onClearText?.();
-                            pushGenerated(msg);
                             const gateMessage = "current held-work frame still has unsurfaced items — return each listed item with surface(delegationId=...) before you settle. Older transcript claims are historical; only the current held-work frame is the gate.";
-                            pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
-                            providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
+                            rejectToolBatch(msg, [gateMessage]);
                             continue;
                         }
                         // Extract answer from the tool call arguments.
@@ -1814,7 +1818,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             streamCallbackBuffer?.discard();
                             callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
                             callbacks.onClearText?.();
-                            queueRequiredCorrection(requiredAnswerRejection, "before required terminal answer validation completed");
+                            queueRequiredCorrection(msg, requiredAnswerRejection, "before required terminal answer validation completed");
                             (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.required_tool_answer_rejected", message: "unsupported settle answer rejected after required reads", meta: { answerLength: answer.length } });
                             continue;
                         }
@@ -1882,10 +1886,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             streamCallbackBuffer?.discard();
                             callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
                             callbacks.onClearText?.();
-                            pushGenerated(msg);
-                            const toolRetryMessage = retryError;
-                            pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: toolRetryMessage });
-                            providerRuntime.appendToolOutput(result.toolCalls[0].id, toolRetryMessage);
+                            rejectToolBatch(msg, [retryError]);
                         }
                         continue;
                     }
@@ -1923,19 +1924,15 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         const attentionQueue = augmentedToolContext?.delegatedOrigins;
                         if (attentionQueue && attentionQueue.length > 0) {
                             callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), false);
-                            pushGenerated(msg);
                             const gateMessage = "current held-work frame still has unsurfaced items — return each listed item with surface(delegationId=...) before you rest. Older transcript claims are historical; only the current held-work frame is the gate.";
-                            pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
-                            providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
+                            rejectToolBatch(msg, [gateMessage]);
                             continue;
                         }
                         if (hasFreshPendingWork(options) && !freshWorkGateFired) {
                             freshWorkGateFired = true;
                             callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), false);
-                            pushGenerated(msg);
                             const gateMessage = "fresh work arrived for me this turn — inspect the pending messages above and take the next concrete action before you rest.";
-                            pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
-                            providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
+                            rejectToolBatch(msg, [gateMessage]);
                             (0, runtime_1.emitNervesEvent)({
                                 level: "info",
                                 component: "engine",
@@ -1967,7 +1964,56 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         if (rejection)
                             requiredDispatchRejections.set(entry.call.id, { name: entry.call.name, args: requiredArgs, message: rejection });
                     }
-                    const approvalCalls = await Promise.all(validCalls.filter((entry) => !requiredDispatchRejections.has(entry.call.id)).map(async (entry) => {
+                    if (requiredDispatchRejections.size > 0) {
+                        streamCallbackBuffer?.discard();
+                        for (const rejection of requiredDispatchRejections.values()) {
+                            callbacks.onToolStart(rejection.name, rejection.args);
+                            callbacks.onToolEnd(rejection.name, (0, tools_1.summarizeArgs)(rejection.name, rejection.args), false);
+                            options?.toolBoundaryObserver?.({
+                                name: rejection.name, reason: "dependency_rejected",
+                                globallyResolvable: typeof (0, tools_1.resolveToolDefinition)(rejection.name)?.handler === "function",
+                                invoked: false, sideEffect: false,
+                            });
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn", component: "engine", event: "engine.required_tool_dispatch_rejected",
+                                message: "required tool dependency rejected before approval and handler dispatch",
+                                meta: { toolName: rejection.name },
+                            });
+                        }
+                        rejectToolBatch(msg, result.toolCalls.map((call) => requiredDispatchRejections.get(call.id)?.message
+                            ?? "rejected: another call in this batch has an unsatisfied required dependency; no handler was executed."));
+                        continue;
+                    }
+                    const executionRejections = new Map();
+                    for (const entry of validCalls) {
+                        const args = validatedCallArguments.get(entry.call);
+                        const fingerprint = effectFingerprint(entry.call.name, entry.call.arguments);
+                        if (forcingHistoricalEffect && fingerprint && !unresolvedHistoricalEffects.some((effect) => effect.fingerprint === fingerprint)) {
+                            executionRejections.set(entry.call.id, "rejected: this turn is retrying an unresolved historical effect, and these mutation arguments do not match it. Read current state or retry the exact failed effect.");
+                        }
+                        else if (entry.call.name === "send_message" && args.friendId === "self" && !isPrivateRuntimeChannel && looksLikePrivateReturnRequest(latestUserMessageText(messages))) {
+                            executionRejections.set(entry.call.id, "private-return requests must use ponder, not send_message(friendId=self). Create a typed ponder packet with the marker/source request preserved, then only acknowledge that the private pass is queued.");
+                        }
+                        else if (entry.call.name !== "speak" && entry.call.name !== "ponder") {
+                            const loop = (0, tool_loop_1.detectToolLoop)(toolLoopState, entry.call.name, args);
+                            if (loop.stuck)
+                                executionRejections.set(entry.call.id, `loop guard: ${loop.message}`);
+                        }
+                    }
+                    if (executionRejections.size > 0) {
+                        streamCallbackBuffer?.discard();
+                        for (const entry of validCalls) {
+                            if (!executionRejections.has(entry.call.id))
+                                continue;
+                            const args = validatedCallArguments.get(entry.call);
+                            callbacks.onToolStart(entry.call.name, args);
+                            callbacks.onToolEnd(entry.call.name, (0, tools_1.summarizeArgs)(entry.call.name, args), false);
+                        }
+                        rejectToolBatch(msg, result.toolCalls.map((call) => executionRejections.get(call.id)
+                            ?? "rejected: another call in this batch was inadmissible; no handler was executed."));
+                        continue;
+                    }
+                    const approvalCalls = await Promise.all(validCalls.map(async (entry) => {
                         const classification = await (0, tools_1.classifyApprovalForInvocation)(entry.call.name, entry.validated.arguments, augmentedToolContext);
                         return {
                             ...entry,
@@ -1977,12 +2023,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     const protectedCall = approvalCalls.find((entry) => entry.policy.kind === "required");
                     if (protectedCall && result.toolCalls.length !== 1) {
                         streamCallbackBuffer?.discard();
-                        pushGenerated(msg);
-                        for (const call of result.toolCalls) {
-                            const rejection = "rejected: approval-eligible tool must be the sole call; no call in this batch was executed.";
-                            pushGenerated({ role: "tool", tool_call_id: call.id, content: rejection });
-                            providerRuntime.appendToolOutput(call.id, rejection);
-                        }
+                        rejectToolBatch(msg, result.toolCalls.map(() => "rejected: approval-eligible tool must be the sole call; no call in this batch was executed."));
                         (0, runtime_1.emitNervesEvent)({
                             level: "warn",
                             component: "engine",
@@ -1995,10 +2036,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     if (protectedCall && protectedCall.policy.kind === "required") {
                         if (!options?.approvalCoordinator) {
                             streamCallbackBuffer?.discard();
-                            pushGenerated(msg);
                             const rejection = "rejected: this protected tool requires approval, but the approval coordinator is unavailable; the handler was not invoked.";
-                            pushGenerated({ role: "tool", tool_call_id: protectedCall.call.id, content: rejection });
-                            providerRuntime.appendToolOutput(protectedCall.call.id, rejection);
+                            rejectToolBatch(msg, [rejection]);
                             (0, runtime_1.emitNervesEvent)({
                                 level: "warn",
                                 component: "engine",
@@ -2009,7 +2048,6 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             continue;
                         }
                         streamCallbackBuffer?.discard();
-                        pushGenerated(msg);
                         const toolDigest = (0, tool_arguments_1.digestJson)({
                             name: protectedCall.call.name,
                             schemaDigest: protectedCall.validated.schemaDigest,
@@ -2032,6 +2070,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             actionClass: protectedCall.policy.actionClass,
                             liveToolContext: augmentedToolContext,
                         });
+                        pushGenerated(msg);
                         suspension = {
                             approvalId: committed.approvalId,
                             toolCallId: protectedCall.call.id,
@@ -2048,79 +2087,15 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         });
                         continue;
                     }
-                    const containsSoleCallOnlyViolation = result.toolCalls.length > 1
-                        && result.toolCalls.some((call) => {
-                            const terminalProjection = (0, tools_1.resolveToolDefinition)(call.name)?.terminalProjection;
-                            return SOLE_CALL_REJECTION[call.name] !== undefined
-                                || terminalProjection?.requiresSoleCall === true;
-                        });
-                    if (callbacks.settleOutputMode === "final_only" && containsSoleCallOnlyViolation) {
-                        streamCallbackBuffer?.discard();
-                    }
-                    else {
-                        await streamCallbackBuffer?.flush();
-                    }
+                    await streamCallbackBuffer?.flush();
                     pushGenerated(msg);
-                    // Execute tools (sole-call tools in mixed calls are rejected inline)
+                    // Every pre-dispatch gate accepted the complete batch.
                     for (const tc of result.toolCalls) {
                         if (signal?.aborted)
                             break;
-                        const requiredDispatchRejection = requiredDispatchRejections.get(tc.id);
-                        if (requiredDispatchRejection) {
-                            callbacks.onToolStart(tc.name, requiredDispatchRejection.args);
-                            callbacks.onToolEnd(tc.name, (0, tools_1.summarizeArgs)(tc.name, requiredDispatchRejection.args), false);
-                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: requiredDispatchRejection.message });
-                            providerRuntime.appendToolOutput(tc.id, requiredDispatchRejection.message);
-                            options?.toolBoundaryObserver?.({
-                                name: tc.name,
-                                reason: "dependency_rejected",
-                                globallyResolvable: typeof (0, tools_1.resolveToolDefinition)(tc.name)?.handler === "function",
-                                invoked: false,
-                                sideEffect: false,
-                            });
-                            (0, runtime_1.emitNervesEvent)({
-                                level: "warn",
-                                component: "engine",
-                                event: "engine.required_tool_dispatch_rejected",
-                                message: "required tool dependency rejected before approval and handler dispatch",
-                                meta: { toolName: tc.name },
-                            });
-                            continue;
-                        }
-                        // Reject sole-call tools when mixed with other tool calls
-                        const terminalProjection = (0, tools_1.resolveToolDefinition)(tc.name)?.terminalProjection;
-                        const soleCallRejection = SOLE_CALL_REJECTION[tc.name]
-                            ?? (terminalProjection?.requiresSoleCall
-                                ? `rejected: ${tc.name} must be the only tool call.`
-                                : undefined);
-                        if (soleCallRejection) {
-                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: soleCallRejection });
-                            providerRuntime.appendToolOutput(tc.id, soleCallRejection);
-                            continue;
-                        }
                         const args = validatedCallArguments.get(tc);
                         const currentEffectFingerprint = effectFingerprint(tc.name, tc.arguments);
-                        if (forcingHistoricalEffect
-                            && currentEffectFingerprint
-                            && !unresolvedHistoricalEffects.some((effect) => effect.fingerprint === currentEffectFingerprint)) {
-                            const rejection = "rejected: this turn is retrying an unresolved historical effect, and these mutation arguments do not match it. Read current state or retry the exact failed effect.";
-                            callbacks.onToolStart(tc.name, args);
-                            callbacks.onToolEnd(tc.name, (0, tools_1.summarizeArgs)(tc.name, args), false);
-                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: rejection });
-                            providerRuntime.appendToolOutput(tc.id, rejection);
-                            continue;
-                        }
                         if (tc.name === "send_message" && args.friendId === "self") {
-                            const latestUserText = latestUserMessageText(messages);
-                            if (!isPrivateRuntimeChannel && looksLikePrivateReturnRequest(latestUserText)) {
-                                const argSummary = (0, tools_1.summarizeArgs)(tc.name, args);
-                                const rejection = "private-return requests must use ponder, not send_message(friendId=self). Create a typed ponder packet with the marker/source request preserved, then only acknowledge that the private pass is queued.";
-                                callbacks.onToolStart(tc.name, args);
-                                callbacks.onToolEnd(tc.name, argSummary, false);
-                                pushGenerated({ role: "tool", tool_call_id: tc.id, content: rejection });
-                                providerRuntime.appendToolOutput(tc.id, rejection);
-                                continue;
-                            }
                             sawSendMessageSelf = true;
                         }
                         if (tc.name === "speak") {
@@ -2342,16 +2317,6 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         /* v8 ignore next -- flag tested via truth-check integration tests @preserve */
                         if (isExternalStateQuery(tc.name, args))
                             sawExternalStateQuery = true;
-                        const argSummary = (0, tools_1.summarizeArgs)(tc.name, args);
-                        const toolLoop = (0, tool_loop_1.detectToolLoop)(toolLoopState, tc.name, args);
-                        if (toolLoop.stuck) {
-                            const rejection = `loop guard: ${toolLoop.message}`;
-                            callbacks.onToolStart(tc.name, args);
-                            callbacks.onToolEnd(tc.name, argSummary, false);
-                            pushGenerated({ role: "tool", tool_call_id: tc.id, content: rejection });
-                            providerRuntime.appendToolOutput(tc.id, rejection);
-                            continue;
-                        }
                         callbacks.onToolStart(tc.name, args);
                         let toolResult;
                         let success;
@@ -2367,8 +2332,12 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         catch (e) {
                             toolResult = `error: ${e}`;
                             success = false;
-                            augmentedToolContext?.habitSession?.recordError?.(toolResult);
                         }
+                        const modelResult = (0, tool_friction_1.rewriteToolResultForModel)(tc.name, toolResult, toolFrictionLedger);
+                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: modelResult });
+                        providerRuntime.appendToolOutput(tc.id, modelResult);
+                        if (!success)
+                            augmentedToolContext?.habitSession?.recordError?.(toolResult);
                         const validatedRequiredResult = success && requiredToolCallNames.includes(tc.name) && options?.requiredToolCalls?.requireSuccessfulResults
                             ? requiredToolResultSucceeded(tc.name, toolResult, args, options.requiredToolCalls.validateRequiredToolResult)
                             : false;
@@ -2395,20 +2364,17 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             invoked: true,
                             sideEffect: success && toolRiskProfile?.mutates !== "none",
                         });
-                        toolResult = (0, tool_friction_1.rewriteToolResultForModel)(tc.name, toolResult, toolFrictionLedger);
-                        (0, tool_loop_1.recordToolOutcome)(toolLoopState, tc.name, args, toolResult, success);
-                        callbacks.onToolEnd(tc.name, (0, tools_1.buildToolResultSummary)(tc.name, args, toolResult, success), success);
-                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: toolResult });
-                        providerRuntime.appendToolOutput(tc.id, toolResult);
-                        callbacks.onToolResult?.(messagesWithoutRequiredCorrections());
+                        (0, tool_loop_1.recordToolOutcome)(toolLoopState, tc.name, args, modelResult, success);
+                        callbacks.onToolEnd(tc.name, (0, tools_1.buildToolResultSummary)(tc.name, args, modelResult, success), success);
+                        callbacks.onToolResult?.(messages);
                     }
                 }
             }
             catch (e) {
                 // Abort is not an error — just stop cleanly
                 if (e instanceof provider_attempt_1.ProviderAttemptAbortError || signal?.aborted) {
-                    stripLastToolCalls(messages);
-                    stripLastToolCalls(generatedMessages);
+                    if (generatedMessages.length === 0)
+                        stripLastToolCalls(messages);
                     outcome = "aborted";
                     break;
                 }
@@ -2426,7 +2392,9 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         }
     }
     finally {
-        removeRequiredCorrections();
+        nextAttemptControls = [];
+        rejectedAttempt = [];
+        providerRuntime.resetTurnState(messages);
     }
     options?.captureGeneratedMessages?.(structuredClone(generatedMessages));
     (0, runtime_1.emitNervesEvent)({