@caupulican/pi-agent-core 0.93.8 → 0.93.9

package/dist/agent-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAiC7D,OAAO,EAEN,uBAAuB,EAGvB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EAEZ,aAAa,EAEb,QAAQ,EACR,kBAAkB,EAClB,MAAM,YAAY,CAAC;AAIpB,OAAO,EACN,0BAA0B,EAC1B,sBAAsB,EACtB,gCAAgC,GAChC,MAAM,+BAA+B,CAAC;AAEvC,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAKzE,gGAAgG;AAChG,MAAM,WAAW,0BAA0B;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,uBAAuB,EAAE,uBAAuB,CAAC;CACjD;AAED,wBAAgB,gCAAgC,IAAI,0BAA0B,CAE7E;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAEzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAIzC;AAuBD,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,EACnB,iBAAiB,GAAE,0BAA+D,GAChF,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,EACnB,iBAAiB,GAAE,0BAA+D,GAChF,OAAO,CAAC,YAAY,EAAE,CAAC,CAWzB;AAoVD;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC9C,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAExC;AAqlCD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,kBAAkB,GAAG,SAAS,CAO7F"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAgC7D,OAAO,EAAE,uBAAuB,EAAsC,MAAM,iCAAiC,CAAC;AAE9G,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EAEZ,aAAa,EAGb,QAAQ,EACR,kBAAkB,EAClB,MAAM,YAAY,CAAC;AAIpB,OAAO,EACN,0BAA0B,EAC1B,sBAAsB,EACtB,gCAAgC,GAChC,MAAM,+BAA+B,CAAC;AAEvC,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAKzE,gGAAgG;AAChG,MAAM,WAAW,0BAA0B;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,uBAAuB,EAAE,uBAAuB,CAAC;CACjD;AAED,wBAAgB,gCAAgC,IAAI,0BAA0B,CAE7E;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAEzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAIzC;AAuBD,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,EACnB,iBAAiB,GAAE,0BAA+D,GAChF,OAAO,CAAC,YAAY,EAAE,CAAC,CAwBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,EACnB,iBAAiB,GAAE,0BAA+D,GAChF,OAAO,CAAC,YAAY,EAAE,CAAC,CAezB;AAmWD;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC9C,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAExC;AA6iCD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,kBAAkB,GAAG,SAAS,CAO7F"}

package/dist/agent-loop.js

@@ -7,9 +7,9 @@ import { formatToolRepairStandingRule, REPEATED_SUCCESSFUL_TOOL_CALL_FAILURE, }
 import { ToolArgumentValidationError, validateToolArguments, } from "@caupulican/pi-ai/validation";
 import { assistantMessageText, collapseDegenerateAssistantMessage, shouldAbortDegenerateStream, } from "./degenerate-assistant-text.js";
 import { startPlannedAgentProviderRequest } from "./provider-request-planner.js";
-import { assessToolFailure, clearToolFailure, createRepeatedToolFailureResult, createToolFailureMemoryTracker, createToolFailureOperationExhaustedResult, createToolFailureRecoveryExhaustedResult, createToolFailureResult, getUnresolvedToolFailure, normalizeToolSignature, rememberToolFailure, toolFailureCorrection, } from "./tool-failure-memory.js";
-import { ToolFailureRecoveryGate, } from "./tool-failure-recovery-gate.js";
-import { rejectNativeToolProtocolResidue } from "./tool-protocol-residue.js";
+import { assessToolFailure, clearToolFailure, createRepeatedToolFailureResult, createToolFailureMemoryTracker, createToolFailureResult, describeOperationOutcome, getUnresolvedToolFailure, normalizeToolSignature, rememberToolFailure, toolFailureCorrection, } from "./tool-failure-memory.js";
+import { ToolFailureRecoveryGate } from "./tool-failure-recovery-gate.js";
+import { rejectNativeToolProtocolResidue, rejectToolCallsFromToolFreeResponse } from "./tool-protocol-residue.js";
 import { AgentToolExecutionError, DEFAULT_MAX_PROVIDER_TURNS, DEFAULT_MAX_STALL_TURNS } from "./types.js";
 import { createEmptyUsage } from "./usage.js";
 export { composeRequestSystemPrompt, narrowRequestMaxTokens, resolveRequestPreflightMaxTokens, } from "./provider-request-planner.js";
@@ -59,6 +59,14 @@ export async function runAgentLoop(prompts, context, config, emit, signal, strea
         messages: [...context.messages, ...prompts],
     };
     await emit({ type: "agent_start" });
+    if (providerTurnLimitReached(config, continuationState)) {
+        for (const prompt of prompts) {
+            await emit({ type: "message_start", message: prompt });
+            await emit({ type: "message_end", message: prompt });
+        }
+        await emitProviderTurnLimitStop(config, continuationState, newMessages, emit);
+        return newMessages;
+    }
     await emit({ type: "turn_start" });
     for (const prompt of prompts) {
         await emit({ type: "message_start", message: prompt });
@@ -72,6 +80,10 @@ export async function runAgentLoopContinue(context, config, emit, signal, stream
     const newMessages = [];
     const currentContext = { ...context, messages: [...context.messages] };
     await emit({ type: "agent_start" });
+    if (providerTurnLimitReached(config, continuationState)) {
+        await emitProviderTurnLimitStop(config, continuationState, newMessages, emit);
+        return newMessages;
+    }
     await emit({ type: "turn_start" });
     await runLoop(currentContext, newMessages, config, signal, emit, streamFn, continuationState);
     return newMessages;
@@ -97,36 +109,21 @@ function createLoopFailureMessage(error, config, aborted) {
         timestamp: Date.now(),
     };
 }
-function createMandatoryRecoveryDeliveryFallback(halt, config) {
-    const diagnostic = halt.record.diagnostic ?? halt.diagnostic;
-    return createLocalDiagnosticMessage(config, `Tool recovery stopped for ${halt.record.tool}: ${diagnostic} Required recovery: ${halt.record.correction}`);
-}
-function createProviderTurnLimitMessage(config, providerTurns) {
-    return createLocalDiagnosticMessage(config, `Configured provider turn limit (${providerTurns}) reached. The harness stopped before another provider request; continue explicitly if more work is needed.`);
+function createAgentStream() {
+    return new EventStream((event) => event.type === "agent_end", (event) => (event.type === "agent_end" ? event.messages : []));
 }
-function createLocalDiagnosticMessage(config, text) {
-    return {
-        role: "assistant",
-        content: [{ type: "text", text }],
-        api: config.model.api,
-        provider: config.model.provider,
-        model: config.model.id,
-        usage: createEmptyUsage(),
-        stopReason: "stop",
-        timestamp: Date.now(),
-    };
+function providerTurnLimitReached(config, continuationState) {
+    const limit = config.maxProviderTurns ?? DEFAULT_MAX_PROVIDER_TURNS;
+    return limit > 0 && continuationState.providerTurns >= limit;
 }
-async function emitTerminalLocalMessage(message, newMessages, emit, startTurn) {
-    if (startTurn)
-        await emit({ type: "turn_start" });
-    await emit({ type: "message_start", message, origin: "local" });
-    await emit({ type: "message_end", message, origin: "local" });
-    await emit({ type: "turn_end", message, toolResults: [] });
+async function emitProviderTurnLimitStop(config, continuationState, newMessages, emit) {
+    config.onRunawayStop?.({
+        reason: "provider_turn_limit",
+        signature: "provider_turn_limit",
+        repeats: continuationState.providerTurns,
+    });
     await emit({ type: "agent_end", messages: newMessages });
 }
-function createAgentStream() {
-    return new EventStream((event) => event.type === "agent_end", (event) => (event.type === "agent_end" ? event.messages : []));
-}
 /**
  * How many `stallLimit`-length periods the runaway-loop window spans. A window of `stallLimit * P`
  * turns lets the count-based detector catch oscillating cycles of period up to `P` (each signature in a
@@ -206,40 +203,41 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
     let lastSuccessfulTextProtocolBatch;
     // Check for steering messages at start (user may have typed while waiting)
     let pendingMessages = (await config.getSteeringMessages?.()) || [];
+    const processPendingMessages = async () => {
+        if (pendingMessages.length === 0)
+            return;
+        lastSuccessfulTextProtocolBatch = undefined;
+        // A new user turn can change authority, intent, or the workspace itself, so every
+        // operation that was blocked as an unproductive replay becomes worth attempting again.
+        toolFailureRecoveryGate.noteWorldAdvance();
+        for (const message of pendingMessages) {
+            await emit({ type: "message_start", message });
+            await emit({ type: "message_end", message });
+            currentContext.messages.push(message);
+            newMessages.push(message);
+        }
+        pendingMessages = [];
+    };
     // Outer loop: continues when queued follow-up messages arrive after agent would stop
     while (true) {
         let hasMoreToolCalls = true;
         // Inner loop: process tool calls and steering messages
         while (hasMoreToolCalls || pendingMessages.length > 0) {
+            if (providerTurnLimit > 0 && continuationState.providerTurns >= providerTurnLimit) {
+                // Preserve already-dequeued steering, but do not announce an assistant turn that will
+                // never start. A turn is one provider response plus its tools/results.
+                await processPendingMessages();
+                await emitProviderTurnLimitStop(config, continuationState, newMessages, emit);
+                return;
+            }
             if (!firstTurn) {
                 await emit({ type: "turn_start" });
             }
             else {
                 firstTurn = false;
             }
-            // Process pending messages (inject before next assistant response)
-            if (pendingMessages.length > 0) {
-                lastSuccessfulTextProtocolBatch = undefined;
-                for (const message of pendingMessages) {
-                    await emit({ type: "message_start", message });
-                    await emit({ type: "message_end", message });
-                    currentContext.messages.push(message);
-                    newMessages.push(message);
-                }
-                pendingMessages = [];
-            }
-            if (providerTurnLimit > 0 && continuationState.providerTurns >= providerTurnLimit) {
-                const fallback = createProviderTurnLimitMessage(config, continuationState.providerTurns);
-                currentContext.messages.push(fallback);
-                newMessages.push(fallback);
-                config.onRunawayStop?.({
-                    reason: "provider_turn_limit",
-                    signature: "provider_turn_limit",
-                    repeats: continuationState.providerTurns,
-                });
-                await emitTerminalLocalMessage(fallback, newMessages, emit, false);
-                return;
-            }
+            // Process pending messages (inject before next assistant response).
+            await processPendingMessages();
             continuationState.providerTurns++;
             const message = await streamAssistantResponse(currentContext, config, signal, emit, streamFn);
             newMessages.push(message);
@@ -251,7 +249,6 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
             // Check for tool calls
             const toolCalls = message.content.filter((c) => c.type === "toolCall");
             const toolResults = [];
-            let recoveryHalt;
             hasMoreToolCalls = false;
             if (toolCalls.length > 0) {
                 const textProtocolBatch = toolCalls.every((toolCall) => toolCall.source === "text-protocol");
@@ -262,14 +259,7 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
                     : undefined;
                 const executedToolBatch = await executeToolCalls(currentContext, message, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, toolFailureRecoveryGate, previousSuccessfulTextProtocolResults, signal, emit);
                 toolResults.push(...executedToolBatch.messages);
-                if (toolFailureRecoveryGate.isHalted()) {
-                    recoveryHalt = toolFailureRecoveryGate.getHalt();
-                    if (!recoveryHalt)
-                        throw new Error("Tool recovery halted without a failure record");
-                }
-                else {
-                    hasMoreToolCalls = !executedToolBatch.terminate;
-                }
+                hasMoreToolCalls = !executedToolBatch.terminate;
                 for (const result of toolResults) {
                     currentContext.messages.push(result);
                     newMessages.push(result);
@@ -291,13 +281,6 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
                 lastSuccessfulTextProtocolBatch = undefined;
             }
             await emit({ type: "turn_end", message, toolResults });
-            if (recoveryHalt) {
-                const fallback = createMandatoryRecoveryDeliveryFallback(recoveryHalt, config);
-                currentContext.messages.push(fallback);
-                newMessages.push(fallback);
-                await emitTerminalLocalMessage(fallback, newMessages, emit, true);
-                return;
-            }
             // Runaway-loop backstop (cost guard): detect a model stuck repeating one action.
             if (stallLimit > 0 && toolCalls.length > 0) {
                 const signature = normalizeToolSignature(toolCalls.map((c) => [c.name, c.arguments ?? null]));
@@ -307,6 +290,7 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
                 const repeats = stallWindow.reduce((n, s) => (s === signature ? n + 1 : n), 0);
                 if (repeats >= stallLimit) {
                     config.onRunawayStop?.({ reason: "repeated_tool_call", signature, repeats });
+                    await streamToollessClosingTurn(currentContext, newMessages, config, continuationState, providerTurnLimit, signal, emit, streamFn);
                     await emit({ type: "agent_end", messages: newMessages });
                     return;
                 }
@@ -352,6 +336,41 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
     }
     await emit({ type: "agent_end", messages: newMessages });
 }
+const RUNAWAY_STOP_CLOSING_SYSTEM_PROMPT = [
+    "RUNAWAY STOP CLOSING TURN",
+    "The host stopped a repeated tool-call loop. No tools are available in this final request.",
+    "Write one concise factual closing message for the user: completed work, the unresolved operation or blocker, and the safest next action.",
+    "Do not claim unperformed work. Do not emit a tool call or tool-call markup.",
+].join("\n");
+/**
+ * Spend one final provider request, with no tools, so a stopped run closes in the model's own words.
+ *
+ * The harness never writes that message itself. Tools are removed from the request, so this request
+ * cannot open another tool batch and cannot re-enter the loop; it runs through the same planned
+ * provider boundary as every other request. If the run is aborted, or the configured provider-turn
+ * limit leaves no budget, the run ends with no closing message rather than a fabricated one — and a
+ * provider error keeps its own error message for the same reason.
+ */
+async function streamToollessClosingTurn(currentContext, newMessages, config, continuationState, providerTurnLimit, signal, emit, streamFn) {
+    if (signal?.aborted)
+        return;
+    if (providerTurnLimit > 0 && continuationState.providerTurns >= providerTurnLimit)
+        return;
+    continuationState.providerTurns++;
+    await emit({ type: "turn_start" });
+    const closingContext = {
+        ...currentContext,
+        systemPrompt: currentContext.systemPrompt
+            ? `${currentContext.systemPrompt}\n\n${RUNAWAY_STOP_CLOSING_SYSTEM_PROMPT}`
+            : RUNAWAY_STOP_CLOSING_SYSTEM_PROMPT,
+        tools: [],
+    };
+    const message = await streamAssistantResponse(closingContext, config, signal, emit, streamFn, {
+        rejectToolCalls: true,
+    });
+    newMessages.push(message);
+    await emit({ type: "turn_end", message, toolResults: [] });
+}
 /**
  * Start one provider request through the canonical agent-loop boundary.
  *
@@ -366,7 +385,7 @@ export async function startAgentProviderRequest(context, config, signal, streamF
  * Stream an assistant response from the LLM.
  * This is where AgentMessage[] gets transformed to Message[] for the LLM.
  */
-async function streamAssistantResponse(context, config, signal, emit, streamFn) {
+async function streamAssistantResponse(context, config, signal, emit, streamFn, policy) {
     const degenerationAbort = new AbortController();
     const onOuterAbort = () => degenerationAbort.abort();
     if (signal?.aborted)
@@ -417,7 +436,10 @@ async function streamAssistantResponse(context, config, signal, emit, streamFn)
         }
     }
     signal?.removeEventListener("abort", onOuterAbort);
-    let finalMessage = rejectNativeToolProtocolResidue(await response.result(), context.tools ?? [], Boolean(config.textToolCallProtocol));
+    const providerMessage = await response.result();
+    let finalMessage = policy?.rejectToolCalls
+        ? rejectToolCallsFromToolFreeResponse(providerMessage)
+        : rejectNativeToolProtocolResidue(providerMessage, context.tools ?? [], Boolean(config.textToolCallProtocol));
     if (abortedForDegeneration && !signal?.aborted && finalMessage.stopReason === "aborted") {
         finalMessage = { ...finalMessage, stopReason: "stop" };
         delete finalMessage.errorMessage;
@@ -465,7 +487,7 @@ async function prepareAndStartToolCall(execCtx, toolCall, index) {
         emitToolArgumentValidationTelemetry(execCtx.config, preparation.validationEvent, "not_run", "none");
         return {
             kind: "finalized",
-            finalized: finalizeRejectedToolCall(toolCall, execCtx.context.tools?.find((tool) => tool.name === toolCall.name), preparation, execCtx.toolFailureMemory, execCtx.toolFailureRecoveryGate),
+            finalized: finalizeRejectedToolCall(toolCall, execCtx.context.tools?.find((tool) => tool.name === toolCall.name), preparation, execCtx.toolFailureMemory),
         };
     }
     return { kind: "prepared", preparation };
@@ -480,7 +502,8 @@ async function executeToolCallsSequential(execCtx, toolCalls) {
     const messages = [];
     for (const [index, toolCall] of toolCalls.entries()) {
         const started = await prepareAndStartToolCall(execCtx, toolCall, index);
-        const finalized = applyToolFailureRecoveryEffect(execCtx.toolFailureRecoveryGate, await finalizeStartedToolCall(execCtx, started));
+        const finalized = await finalizeStartedToolCall(execCtx, started);
+        execCtx.toolFailureRecoveryGate.apply(finalized.executionGateEffect);
         await emitToolExecutionEnd(finalized, execCtx.emit);
         const toolResultMessage = createToolResultMessage(finalized);
         await emitToolResultMessage(toolResultMessage, execCtx.emit);
@@ -490,10 +513,7 @@ async function executeToolCallsSequential(execCtx, toolCalls) {
             break;
         }
     }
-    return {
-        messages,
-        terminate: execCtx.toolFailureRecoveryGate.isHalted() || shouldTerminateToolBatch(finalizedCalls),
-    };
+    return { messages, terminate: shouldTerminateToolBatch(finalizedCalls) };
 }
 async function executeToolCallsParallel(execCtx, toolCalls) {
     const orderedFinalizedCalls = [];
@@ -523,15 +543,11 @@ async function executeToolCallsParallel(execCtx, toolCalls) {
                 break;
             }
         }
-        const unappliedWave = await Promise.all(wave.map((entry) => (typeof entry === "function" ? entry() : Promise.resolve(entry))));
-        const appliedByOriginal = new Map();
-        const finalizedWave = unappliedWave.map((finalized) => {
-            const applied = applyToolFailureRecoveryEffect(execCtx.toolFailureRecoveryGate, finalized);
-            appliedByOriginal.set(finalized, applied);
-            return applied;
-        });
+        const finalizedWave = await Promise.all(wave.map((entry) => (typeof entry === "function" ? entry() : Promise.resolve(entry))));
+        for (const finalized of finalizedWave)
+            execCtx.toolFailureRecoveryGate.apply(finalized.executionGateEffect);
         for (const finalized of completionOrder) {
-            await emitToolExecutionEnd(appliedByOriginal.get(finalized) ?? finalized, execCtx.emit);
+            await emitToolExecutionEnd(finalized, execCtx.emit);
         }
         orderedFinalizedCalls.push(...finalizedWave);
     }
@@ -541,27 +557,7 @@ async function executeToolCallsParallel(execCtx, toolCalls) {
         await emitToolResultMessage(toolResultMessage, execCtx.emit);
         messages.push(toolResultMessage);
     }
-    return {
-        messages,
-        terminate: execCtx.toolFailureRecoveryGate.isHalted() || shouldTerminateToolBatch(orderedFinalizedCalls),
-    };
-}
-function applyToolFailureRecoveryEffect(gate, finalized) {
-    const halt = gate.apply(finalized.executionGateEffect);
-    if (!halt)
-        return finalized;
-    return createRecoveryExhaustedToolCallOutcome(finalized, halt);
-}
-function createRecoveryExhaustedToolCallOutcome(finalized, halt) {
-    const exhaustedResult = createToolFailureRecoveryExhaustedResult(halt.record, halt.diagnostic);
-    return {
-        ...finalized,
-        result: {
-            ...exhaustedResult,
-            ...(finalized.result.usage ? { usage: finalized.result.usage } : {}),
-        },
-        isError: true,
-    };
+    return { messages, terminate: shouldTerminateToolBatch(orderedFinalizedCalls) };
 }
 const DEFAULT_TOOL_VALIDATION_ESCALATION_THRESHOLD = 3;
 const TOOL_REPAIR_TEACH_EVERY = 5;
@@ -586,7 +582,7 @@ function createRepeatedSuccessfulToolCallOutcome(previousResult) {
         ...(previousResult ? { repeatedSuccessfulCall: { previousToolCallId: previousResult.toolCallId } } : {}),
     };
 }
-function createAbortedToolCallOutcome(validationEvent, executionGateReservation) {
+function createAbortedToolCallOutcome(validationEvent) {
     return {
         kind: "immediate",
         result: createErrorToolResult("Operation aborted"),
@@ -594,7 +590,6 @@ function createAbortedToolCallOutcome(validationEvent, executionGateReservation)
         phase: "cancelled",
         failureCode: "aborted",
         correction: "Retry only if the operation is still required.",
-        ...(executionGateReservation ? { executionGateReservation } : {}),
         validationEvent,
     };
 }
@@ -717,7 +712,6 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
         };
     }
     let validationEvent;
-    let executionGateReservation;
     try {
         const preparedToolCall = prepareToolCallArguments(tool, toolCall);
         const validatedArgs = validateToolArguments(tool, preparedToolCall, {
@@ -739,16 +733,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
         const unresolvedRecord = getUnresolvedToolFailure(toolFailureMemory, toolCall.name, validatedArgs);
         const admission = toolFailureRecoveryGate.admit(tool, validatedArgs, unresolvedRecord, currentContext.messages);
         if (admission.kind === "blocked") {
-            const failureCode = admission.exhausted
-                ? admission.scope === "operation"
-                    ? "operation_recovery_exhausted"
-                    : "recovery_exhausted"
-                : "repeated_failed_operation";
-            const result = admission.exhausted
-                ? admission.scope === "operation"
-                    ? createToolFailureOperationExhaustedResult(admission.record, admission.diagnostic ?? "Tool operation recovery budget exhausted.")
-                    : createToolFailureRecoveryExhaustedResult(admission.record, admission.diagnostic ?? "Tool failure recovery budget exhausted.")
-                : createRepeatedToolFailureResult(admission.record);
+            const result = createRepeatedToolFailureResult(admission.record);
             const memoryRecord = result.details.piToolFailureMemory;
             toolFailureMemory.set(admission.record.failureKey, memoryRecord);
             return {
@@ -756,14 +741,13 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
                 result,
                 isError: true,
                 phase: admission.record.phase,
-                failureCode,
+                failureCode: "repeated_failed_operation",
                 correction: memoryRecord.correction,
                 diagnostic: memoryRecord.diagnostic,
                 repeatedToolFailure: true,
-                validationEvent: createValidationBounceTelemetry(config, toolCall, failureCode),
+                validationEvent: createValidationBounceTelemetry(config, toolCall, "repeated_failed_operation"),
             };
         }
-        executionGateReservation = admission.reservation;
         if (config.beforeToolCall) {
             const beforeResult = await config.beforeToolCall({
                 assistantMessage,
@@ -772,7 +756,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
                 context: currentContext,
             }, signal);
             if (signal?.aborted) {
-                return createAbortedToolCallOutcome(validationEvent, executionGateReservation);
+                return createAbortedToolCallOutcome(validationEvent);
             }
             if (beforeResult?.block) {
                 const reason = beforeResult.reason || "Tool execution was blocked";
@@ -784,20 +768,18 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
                     failureCode: "blocked",
                     correction: "Choose an allowed approach or request the required authority before retrying.",
                     diagnostic: reason,
-                    ...(executionGateReservation ? { executionGateReservation } : {}),
                     validationEvent,
                 };
             }
         }
         if (signal?.aborted) {
-            return createAbortedToolCallOutcome(validationEvent, executionGateReservation);
+            return createAbortedToolCallOutcome(validationEvent);
         }
         return {
             kind: "prepared",
             toolCall,
             tool,
             args: validatedArgs,
-            ...(executionGateReservation ? { executionGateReservation } : {}),
             validationEvent,
         };
     }
@@ -817,12 +799,11 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
                 ? validationFailureCorrection(validationEvent, toolCall.name)
                 : toolFailureCorrection(message, "rejected", "preflight"),
             diagnostic: isToolArgumentValidationError(error) ? undefined : message,
-            ...(executionGateReservation ? { executionGateReservation } : {}),
             validationEvent,
         };
     }
 }
-function finalizeRejectedToolCall(toolCall, tool, outcome, tracker, toolFailureRecoveryGate) {
+function finalizeRejectedToolCall(toolCall, tool, outcome, tracker) {
     if (outcome.repeatedToolFailure) {
         return {
             toolCall,
@@ -836,16 +817,7 @@ function finalizeRejectedToolCall(toolCall, tool, outcome, tracker, toolFailureR
             .map((block) => block.text)
             .join("\n"),
     });
-    const halt = toolFailureRecoveryGate.apply({
-        kind: "failure",
-        ...(tool ? { tool } : {}),
-        record,
-        args: toolCall.arguments,
-        ...(outcome.executionGateReservation ? { reservation: outcome.executionGateReservation } : {}),
-    });
-    const failureResult = halt
-        ? createToolFailureRecoveryExhaustedResult(halt.record, halt.diagnostic)
-        : createToolFailureResult(record, outcome.result.terminate);
+    const failureResult = createToolFailureResult(record, outcome.result.terminate);
     return {
         toolCall,
         result: outcome.repeatedSuccessfulCall
@@ -858,6 +830,12 @@ function finalizeRejectedToolCall(toolCall, tool, outcome, tracker, toolFailureR
             }
             : failureResult,
         isError: true,
+        executionGateEffect: {
+            kind: "unproductive",
+            ...(tool ? { tool } : {}),
+            record,
+            args: toolCall.arguments,
+        },
     };
 }
 function createLinkedToolAbort(foregroundSignal) {
@@ -941,7 +919,13 @@ async function executeAndFinalizePreparedToolCall(currentContext, assistantMessa
     if (executionAbort.signal.aborted)
         return completion;
     let handoffAccepted = false;
-    const handedOffCompletion = completion.then((finalized) => handoffAccepted ? applyToolFailureRecoveryEffect(toolFailureRecoveryGate, finalized) : finalized);
+    // A handed-off call leaves the batch, so the batch never applies its effect: the background
+    // completion is the only place left that can tell the governor what this operation did.
+    const handedOffCompletion = completion.then((finalized) => {
+        if (handoffAccepted)
+            toolFailureRecoveryGate.apply(finalized.executionGateEffect);
+        return finalized;
+    });
     void handedOffCompletion.catch(() => undefined);
     let handoff;
     try {
@@ -988,7 +972,9 @@ async function executePreparedToolCall(prepared, signal, emit) {
             // throwing. Keep the returned result intact through afterToolCall so
             // policy hooks can inspect its bounded diagnostics and metadata.
             isError: result.isError === true,
-            ...(result.isError === true ? { errorClass: "tool_result_error" } : {}),
+            ...(result.isError === true
+                ? { errorClass: "tool_result_error", errorKind: result.errorKind ?? "tool_failure" }
+                : {}),
         };
     }
     catch (error) {
@@ -1000,6 +986,7 @@ async function executePreparedToolCall(prepared, signal, emit) {
             isError: true,
             errorClass: error instanceof Error ? error.name : typeof error,
             failureMessage: message,
+            errorKind: toolFailure?.errorKind ?? "tool_failure",
             ...(toolFailure ? { failureCode: toolFailure.failureCode, outputSignature: toolFailure.outputSignature } : {}),
         };
     }
@@ -1035,6 +1022,7 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
     let errorClass = executed.errorClass;
     let failureCode = executed.failureCode;
     let outputSignature = executed.outputSignature;
+    let errorKind = executed.errorKind;
     let executionGateEffect;
     if (config.afterToolCall) {
         try {
@@ -1057,10 +1045,12 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
             }
         }
         catch (error) {
+            // The hook itself failed, so nothing about the tool's own completed operation survives.
             failureMessage = error instanceof Error ? error.message : String(error);
             errorClass = error instanceof Error ? error.name : typeof error;
             failureCode = undefined;
             outputSignature = undefined;
+            errorKind = "tool_failure";
             result = { ...createErrorToolResult(failureMessage), usage: result.usage };
             isError = true;
         }
@@ -1076,20 +1066,34 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
         const effectiveFailureMessage = failureMessage || result.content.find((block) => block.type === "text")?.text || "Tool execution failed";
         const assessment = assessToolFailure(effectiveFailureMessage, "failed", errorClass);
         const effectiveFailureCode = failureCode ?? assessment.failureCode;
-        const recoveryPlan = toolFailureRecoveryGate.planFailure(prepared.tool, prepared.args, { failureCode: effectiveFailureCode, message: effectiveFailureMessage }, currentContext.tools ?? [], prepared.executionGateReservation);
-        const correction = assessment.policyGuidance
-            ? `${assessment.policyGuidance} ${recoveryPlan.guidance}`
-            : recoveryPlan.guidance;
-        const record = rememberToolFailure(toolFailureMemory, prepared.toolCall.name, prepared.args, "failed", effectiveFailureCode, correction, assessment.diagnostic, assessment.phase, recoveryPlan.evidence ?? assessment.evidence, { output: failureOutput, outputSignature });
-        executionGateEffect = {
-            kind: "failure",
-            tool: prepared.tool,
-            record,
-            args: prepared.args,
-            targets: recoveryPlan.targets,
-            ...(prepared.executionGateReservation ? { reservation: prepared.executionGateReservation } : {}),
-        };
-        result = { ...createToolFailureResult(record, result.terminate), usage };
+        if (errorKind === "operation_outcome") {
+            // The tool ran the operation to completion; the non-zero status is the observation the
+            // agent asked for. Nothing here is a mistake, so no failure record is remembered and the
+            // tool's own output stands exactly as written. The governor still notes that repeating
+            // this identical operation cannot say anything new until something else changes.
+            clearToolFailure(toolFailureMemory, prepared.toolCall.name, prepared.args);
+            result = { ...result, errorKind: "operation_outcome", usage };
+            executionGateEffect = {
+                kind: "unproductive",
+                tool: prepared.tool,
+                record: describeOperationOutcome(prepared.toolCall.name, prepared.args, effectiveFailureCode, assessment.diagnostic),
+                args: prepared.args,
+            };
+        }
+        else {
+            const recoveryPlan = toolFailureRecoveryGate.planFailure(prepared.tool, prepared.args, { failureCode: effectiveFailureCode, message: effectiveFailureMessage }, currentContext.tools ?? []);
+            const correction = assessment.policyGuidance
+                ? `${assessment.policyGuidance} ${recoveryPlan.guidance}`
+                : recoveryPlan.guidance;
+            const record = rememberToolFailure(toolFailureMemory, prepared.toolCall.name, prepared.args, "failed", effectiveFailureCode, correction, assessment.diagnostic, assessment.phase, recoveryPlan.evidence ?? assessment.evidence, { output: failureOutput, outputSignature });
+            executionGateEffect = {
+                kind: "unproductive",
+                tool: prepared.tool,
+                record,
+                args: prepared.args,
+            };
+            result = { ...createToolFailureResult(record, result.terminate), usage };
+        }
     }
     else {
         clearToolFailure(toolFailureMemory, prepared.toolCall.name, prepared.args);
@@ -1098,7 +1102,6 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
                 kind: "success",
                 tool: prepared.tool,
                 args: prepared.args,
-                evidenceResult: executed.result,
             };
         }
     }
@@ -1156,6 +1159,9 @@ function createToolResultMessage(finalized) {
         details: finalized.result.details,
         usage: finalized.result.usage,
         isError: finalized.isError,
+        // Persisted so a reloaded transcript still separates a completed operation's own status from a
+        // tool that could not run at all.
+        ...(finalized.isError && finalized.result.errorKind ? { errorKind: finalized.result.errorKind } : {}),
         timestamp: Date.now(),
     };
 }