@caupulican/pi-agent-core 0.85.0 → 0.85.4

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;AAqB7D,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EAEZ,aAAa,EAGb,uBAAuB,EACvB,sBAAsB,EACtB,QAAQ,EACR,kBAAkB,EAClB,MAAM,YAAY,CAAC;AAIpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;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,GACjB,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,GACjB,OAAO,CAAC,YAAY,EAAE,CAAC,CAWzB;AAyCD;;;;GAIG;AACH,wBAAsB,gCAAgC,CAAC,OAAO,EAAE;IAC/D,gBAAgB,CAAC,EAAE,CAClB,OAAO,EAAE,uBAAuB,EAChC,MAAM,CAAC,EAAE,WAAW,KAChB,sBAAsB,GAAG,SAAS,GAAG,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAAC;IACtF,KAAK,EAAE,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACxC,OAAO,EAAE,uBAAuB,CAAC,SAAS,CAAC,CAAC;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAmB9B;AA2JD;;;;;;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,CA8CxC;AAu2BD,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;AAyB7D,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EAEZ,aAAa,EAGb,uBAAuB,EACvB,sBAAsB,EACtB,QAAQ,EACR,kBAAkB,EAClB,MAAM,YAAY,CAAC;AAIpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;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,GACjB,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,GACjB,OAAO,CAAC,YAAY,EAAE,CAAC,CAWzB;AAyFD;;;;GAIG;AACH,wBAAsB,gCAAgC,CAAC,OAAO,EAAE;IAC/D,gBAAgB,CAAC,EAAE,CAClB,OAAO,EAAE,uBAAuB,EAChC,MAAM,CAAC,EAAE,WAAW,KAChB,sBAAsB,GAAG,SAAS,GAAG,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAAC;IACtF,KAAK,EAAE,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACxC,OAAO,EAAE,uBAAuB,CAAC,SAAS,CAAC,CAAC;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAmB9B;AAmLD;;;;;;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,CA8CxC;AA47BD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,kBAAkB,GAAG,SAAS,CAO7F"}

package/dist/agent-loop.js

@@ -4,7 +4,7 @@
  */
 import { EventStream } from "@caupulican/pi-ai/event-stream";
 import { streamSimple } from "@caupulican/pi-ai/stream";
-import { formatToolRepairStandingRule } from "@caupulican/pi-ai/tool-repair-registry";
+import { formatToolRepairStandingRule, REPEATED_SUCCESSFUL_TOOL_CALL_FAILURE, } from "@caupulican/pi-ai/tool-repair-registry";
 import { ToolArgumentValidationError, validateToolArguments, } from "@caupulican/pi-ai/validation";
 import { assessToolFailure, clearToolFailure, createToolFailureMemoryTracker, createToolFailureResult, normalizeToolSignature, rememberToolFailure, sanitizeToolFailureContext, toolFailureCorrection, } from "./tool-failure-memory.js";
 import { DEFAULT_MAX_STALL_TURNS } from "./types.js";
@@ -98,6 +98,51 @@ function createAgentStream() {
  * enough that it's indistinguishable from legitimate varied work, so we don't chase it.
  */
 const STALL_WINDOW_PERIODS = 4;
+function textProtocolOperationArguments(toolCall) {
+    const args = toolCall.arguments;
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        return args ?? null;
+    const record = args;
+    if ((toolCall.name === "write" || toolCall.name === "edit") && typeof record.path === "string") {
+        return { path: record.path };
+    }
+    return args;
+}
+function textProtocolBatchSignature(toolCalls) {
+    return normalizeToolSignature(toolCalls.map((toolCall) => [toolCall.name, textProtocolOperationArguments(toolCall)]));
+}
+function toolCallRecord(toolCall) {
+    const args = toolCall.arguments;
+    return args && typeof args === "object" && !Array.isArray(args) ? args : undefined;
+}
+function toolResultPhase(result) {
+    if (!result.details || typeof result.details !== "object" || Array.isArray(result.details))
+        return undefined;
+    const phase = result.details.phase;
+    return typeof phase === "string" ? phase : undefined;
+}
+function repeatsSuccessfulTextProtocolBatch(incomingSignature, toolCalls, previous) {
+    if (!previous)
+        return false;
+    if (incomingSignature === previous.signature)
+        return true;
+    if (toolCalls.length !== previous.calls.length || toolCalls.length !== previous.messages.length)
+        return false;
+    return toolCalls.every((toolCall, index) => {
+        const previousCall = previous.calls[index];
+        const previousResult = previous.messages[index];
+        if (!previousCall || !previousResult)
+            return false;
+        const currentArgs = toolCallRecord(toolCall);
+        const previousArgs = toolCallRecord(previousCall);
+        if (currentArgs?.path !== previousArgs?.path)
+            return false;
+        const phase = toolResultPhase(previousResult);
+        if (phase === "written")
+            return toolCall.name === "write" && previousCall.name === "write";
+        return phase === "edited" && toolCall.name === "edit" && previousCall.name === "edit";
+    });
+}
 /**
  * Apply one request-local preflight without mutating persistent loop configuration.
  * Shared with isolated tool-free provider calls so every transport boundary has identical
@@ -144,6 +189,7 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
     const validationFailureTracker = { repeats: 0 };
     const repairTeachTracker = new Map();
     let toolFailureMemory = createToolFailureMemoryTracker(currentContext.messages);
+    let lastSuccessfulTextProtocolBatch;
     // Check for steering messages at start (user may have typed while waiting)
     let pendingMessages = (await config.getSteeringMessages?.()) || [];
     // Outer loop: continues when queued follow-up messages arrive after agent would stop
@@ -159,6 +205,7 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
             }
             // 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 });
@@ -180,13 +227,34 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
             const toolResults = [];
             hasMoreToolCalls = false;
             if (toolCalls.length > 0) {
-                const executedToolBatch = await executeToolCalls(currentContext, message, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, signal, emit);
+                const textProtocolBatch = toolCalls.every((toolCall) => toolCall.source === "text-protocol");
+                const incomingBatchSignature = textProtocolBatchSignature(toolCalls);
+                const previousSuccessfulTextProtocolResults = textProtocolBatch &&
+                    repeatsSuccessfulTextProtocolBatch(incomingBatchSignature, toolCalls, lastSuccessfulTextProtocolBatch)
+                    ? lastSuccessfulTextProtocolBatch?.messages
+                    : undefined;
+                const executedToolBatch = await executeToolCalls(currentContext, message, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, previousSuccessfulTextProtocolResults, signal, emit);
                 toolResults.push(...executedToolBatch.messages);
                 hasMoreToolCalls = !executedToolBatch.terminate;
                 for (const result of toolResults) {
                     currentContext.messages.push(result);
                     newMessages.push(result);
                 }
+                if (!previousSuccessfulTextProtocolResults) {
+                    lastSuccessfulTextProtocolBatch =
+                        textProtocolBatch &&
+                            toolResults.length === toolCalls.length &&
+                            toolResults.every((result) => !result.isError)
+                            ? {
+                                signature: textProtocolBatchSignature(toolCalls),
+                                messages: toolResults,
+                                calls: toolCalls,
+                            }
+                            : undefined;
+                }
+            }
+            else {
+                lastSuccessfulTextProtocolBatch = undefined;
             }
             await emit({ type: "turn_end", message, toolResults });
             // Runaway-loop backstop (cost guard): detect a model stuck repeating one action.
@@ -358,27 +426,36 @@ async function streamAssistantResponse(context, config, signal, emit, streamFn)
 /**
  * Execute tool calls from an assistant message.
  */
-async function executeToolCalls(currentContext, assistantMessage, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, signal, emit) {
+async function executeToolCalls(currentContext, assistantMessage, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, previousSuccessfulTextProtocolResults, signal, emit) {
     const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
     const hasSequentialToolCall = toolCalls.some((tc) => currentContext.tools?.find((t) => t.name === tc.name)?.executionMode === "sequential");
     if (config.toolExecution === "sequential" || hasSequentialToolCall) {
-        return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, signal, emit);
+        return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, previousSuccessfulTextProtocolResults, signal, emit);
+    }
+    return executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, previousSuccessfulTextProtocolResults, signal, emit);
+}
+async function prepareAndStartToolCall(currentContext, assistantMessage, toolCall, index, config, validationFailureTracker, toolFailureMemory, previousSuccessfulTextProtocolResults, signal, emit) {
+    const preparation = previousSuccessfulTextProtocolResults
+        ? createRepeatedSuccessfulToolCallOutcome(previousSuccessfulTextProtocolResults[index])
+        : await prepareToolCall(currentContext, assistantMessage, toolCall, config, validationFailureTracker, signal);
+    await emitToolExecutionStart(toolCall, emit);
+    if (preparation.kind === "immediate") {
+        emitToolArgumentValidationTelemetry(config, preparation.validationEvent, "not_run", "none");
+        return { kind: "finalized", finalized: finalizeRejectedToolCall(toolCall, preparation, toolFailureMemory) };
     }
-    return executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, signal, emit);
+    return { kind: "prepared", preparation };
 }
-async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, signal, emit) {
+async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, previousSuccessfulTextProtocolResults, signal, emit) {
     const finalizedCalls = [];
     const messages = [];
-    for (const toolCall of toolCalls) {
-        const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, validationFailureTracker, signal);
-        await emitToolExecutionStart(toolCall, emit);
+    for (const [index, toolCall] of toolCalls.entries()) {
+        const started = await prepareAndStartToolCall(currentContext, assistantMessage, toolCall, index, config, validationFailureTracker, toolFailureMemory, previousSuccessfulTextProtocolResults, signal, emit);
         let finalized;
-        if (preparation.kind === "immediate") {
-            emitToolArgumentValidationTelemetry(config, preparation.validationEvent, "not_run", "none");
-            finalized = finalizeRejectedToolCall(toolCall, preparation, toolFailureMemory);
+        if (started.kind === "finalized") {
+            finalized = started.finalized;
         }
         else {
-            finalized = await executeAndFinalizePreparedToolCall(currentContext, assistantMessage, preparation, config, repairTeachTracker, toolFailureMemory, signal, emit);
+            finalized = await executeAndFinalizePreparedToolCall(currentContext, assistantMessage, started.preparation, config, repairTeachTracker, toolFailureMemory, signal, emit);
         }
         await emitToolExecutionEnd(finalized, emit);
         const toolResultMessage = createToolResultMessage(finalized);
@@ -394,23 +471,20 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
         terminate: shouldTerminateToolBatch(finalizedCalls),
     };
 }
-async function executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, signal, emit) {
+async function executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, validationFailureTracker, repairTeachTracker, toolFailureMemory, previousSuccessfulTextProtocolResults, signal, emit) {
     const finalizedCalls = [];
-    for (const toolCall of toolCalls) {
-        const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, validationFailureTracker, signal);
-        await emitToolExecutionStart(toolCall, emit);
-        if (preparation.kind === "immediate") {
-            emitToolArgumentValidationTelemetry(config, preparation.validationEvent, "not_run", "none");
-            const finalized = finalizeRejectedToolCall(toolCall, preparation, toolFailureMemory);
-            await emitToolExecutionEnd(finalized, emit);
-            finalizedCalls.push(finalized);
+    for (const [index, toolCall] of toolCalls.entries()) {
+        const started = await prepareAndStartToolCall(currentContext, assistantMessage, toolCall, index, config, validationFailureTracker, toolFailureMemory, previousSuccessfulTextProtocolResults, signal, emit);
+        if (started.kind === "finalized") {
+            await emitToolExecutionEnd(started.finalized, emit);
+            finalizedCalls.push(started.finalized);
             if (signal?.aborted) {
                 break;
             }
             continue;
         }
         finalizedCalls.push(async () => {
-            const finalized = await executeAndFinalizePreparedToolCall(currentContext, assistantMessage, preparation, config, repairTeachTracker, toolFailureMemory, signal, emit);
+            const finalized = await executeAndFinalizePreparedToolCall(currentContext, assistantMessage, started.preparation, config, repairTeachTracker, toolFailureMemory, signal, emit);
             await emitToolExecutionEnd(finalized, emit);
             return finalized;
         });
@@ -432,6 +506,27 @@ async function executeToolCallsParallel(currentContext, assistantMessage, toolCa
 }
 const DEFAULT_TOOL_VALIDATION_ESCALATION_THRESHOLD = 3;
 const TOOL_REPAIR_TEACH_EVERY = 5;
+const REPEATED_SUCCESS_RESULT_MAX_CHARS = 2_048;
+function createRepeatedSuccessfulToolCallOutcome(previousResult) {
+    const previousText = previousResult?.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n")
+        .slice(0, REPEATED_SUCCESS_RESULT_MAX_CHARS);
+    const diagnostic = previousText
+        ? `${REPEATED_SUCCESSFUL_TOOL_CALL_FAILURE.diagnostic} Previous successful result: ${previousText}`
+        : REPEATED_SUCCESSFUL_TOOL_CALL_FAILURE.diagnostic;
+    return {
+        kind: "immediate",
+        result: createErrorToolResult(diagnostic),
+        isError: true,
+        phase: "execution",
+        failureCode: REPEATED_SUCCESSFUL_TOOL_CALL_FAILURE.failureCode,
+        correction: REPEATED_SUCCESSFUL_TOOL_CALL_FAILURE.guidance,
+        diagnostic,
+        ...(previousResult ? { repeatedSuccessfulCall: { previousToolCallId: previousResult.toolCallId } } : {}),
+    };
+}
 function shouldTerminateToolBatch(finalizedCalls) {
     return finalizedCalls.length > 0 && finalizedCalls.every((finalized) => finalized.result.terminate === true);
 }
@@ -527,25 +622,27 @@ function handleValidationFailure(error, config, tracker) {
     return `${error.message}\n\nRepeated validation failure (${tracker.repeats} identical attempts). Use this full schema and example before retrying:\n${error.enrichment}`;
 }
 async function prepareToolCall(currentContext, assistantMessage, toolCall, config, validationFailureTracker, signal) {
-    if (toolCall.errorMessage) {
+    const tool = currentContext.tools?.find((candidate) => candidate.name === toolCall.name);
+    if (!tool) {
         return {
             kind: "immediate",
-            result: createErrorToolResult(toolCall.errorMessage),
+            result: createErrorToolResult(`Tool ${toolCall.name} not found`),
             isError: true,
-            failureCode: "malformed_call",
-            correction: "Resend one complete JSON argument object matching the current tool schema.",
+            phase: "validation",
+            failureCode: "unknown_tool",
+            correction: "Choose a tool from the currently available tool list.",
             validationEvent: createValidationBounceTelemetry(config, toolCall, "unknown_tool"),
         };
     }
-    const tool = currentContext.tools?.find((t) => t.name === toolCall.name);
-    if (!tool) {
+    if (toolCall.errorMessage) {
         return {
             kind: "immediate",
-            result: createErrorToolResult(`Tool ${toolCall.name} not found`),
+            result: createErrorToolResult(toolCall.errorMessage),
             isError: true,
-            failureCode: "unknown_tool",
-            correction: "Choose a tool from the currently available tool list.",
-            validationEvent: createValidationBounceTelemetry(config, toolCall, "unknown_tool"),
+            phase: "validation",
+            failureCode: "malformed_call",
+            correction: "Resend one complete JSON argument object matching the current tool schema.",
+            validationEvent: createValidationBounceTelemetry(config, toolCall, "malformed_call"),
         };
     }
     let validationEvent;
@@ -579,6 +676,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
                     kind: "immediate",
                     result: createErrorToolResult("Operation aborted"),
                     isError: true,
+                    phase: "cancelled",
                     failureCode: "aborted",
                     correction: "Retry only if the operation is still required.",
                     validationEvent,
@@ -590,6 +688,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
                     kind: "immediate",
                     result: createErrorToolResult(reason),
                     isError: true,
+                    phase: "policy",
                     failureCode: "blocked",
                     correction: "Choose an allowed approach or request the required authority before retrying.",
                     diagnostic: reason,
@@ -602,6 +701,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
                 kind: "immediate",
                 result: createErrorToolResult("Operation aborted"),
                 isError: true,
+                phase: "cancelled",
                 failureCode: "aborted",
                 correction: "Retry only if the operation is still required.",
                 validationEvent,
@@ -625,19 +725,30 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
             kind: "immediate",
             result: createErrorToolResult(message),
             isError: true,
+            phase: isToolArgumentValidationError(error) ? "validation" : "preflight",
             failureCode: isToolArgumentValidationError(error) ? "invalid_arguments" : "preflight_error",
             correction: isToolArgumentValidationError(error)
                 ? validationFailureCorrection(validationEvent, toolCall.name)
-                : toolFailureCorrection(message, "rejected"),
+                : toolFailureCorrection(message, "rejected", "preflight"),
+            diagnostic: isToolArgumentValidationError(error) ? undefined : message,
             validationEvent,
         };
     }
 }
 function finalizeRejectedToolCall(toolCall, outcome, tracker) {
-    const record = rememberToolFailure(tracker, toolCall.name, toolCall.arguments, "rejected", outcome.failureCode, outcome.correction, outcome.diagnostic);
+    const record = rememberToolFailure(tracker, toolCall.name, toolCall.arguments, "rejected", outcome.failureCode, outcome.correction, outcome.diagnostic, outcome.phase);
+    const failureResult = createToolFailureResult(record, outcome.result.terminate);
     return {
         toolCall,
-        result: createToolFailureResult(record, outcome.result.terminate),
+        result: outcome.repeatedSuccessfulCall
+            ? {
+                ...failureResult,
+                details: {
+                    ...failureResult.details,
+                    piRepeatedSuccessfulCall: outcome.repeatedSuccessfulCall,
+                },
+            }
+            : failureResult,
         isError: true,
     };
 }
@@ -838,7 +949,7 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
         const usage = result.usage;
         const effectiveFailureMessage = failureMessage || result.content.find((block) => block.type === "text")?.text || "Tool execution failed";
         const assessment = assessToolFailure(effectiveFailureMessage, "failed", errorClass);
-        const record = rememberToolFailure(toolFailureMemory, prepared.toolCall.name, prepared.args, "failed", assessment.failureCode, assessment.guidance, assessment.diagnostic);
+        const record = rememberToolFailure(toolFailureMemory, prepared.toolCall.name, prepared.args, "failed", assessment.failureCode, assessment.guidance, assessment.diagnostic, assessment.phase);
         result = { ...createToolFailureResult(record, result.terminate), usage };
     }
     else {