@caupulican/pi-agent-core 0.93.4 → 0.93.7

package/dist/tool-failure-memory.js

@@ -7,7 +7,7 @@ const TOOL_FAILURE_EXECUTION_KEY = Symbol("ToolFailureExecutionKey");
 const MAX_OPERATION_CHARS = 240;
 const MAX_FAILURE_CODE_CHARS = 48;
 const MAX_DIAGNOSTIC_CHARS = 240;
-const MAX_CORRECTION_CHARS = 320;
+const MAX_CORRECTION_CHARS = 480;
 const MAX_TOOL_FAILURE_EVIDENCE_CHARS = 1_600;
 const MAX_ACTIVE_FAILURE_EVIDENCE_CHARS = 2_400;
 const MAX_TOOL_NAME_CHARS = 64;
@@ -16,8 +16,8 @@ const MAX_ACTIVE_FAILURES = 8;
 const MAX_TRACKED_FAILURES = 64;
 const REPAIRABLE_REJECTION_CODES = new Set(["invalid_arguments", "malformed_call", "unknown_tool"]);
 const LEGACY_GENERIC_EXECUTION_CORRECTION = "Change the arguments or approach before retrying; do not resend the unchanged operation.";
-const BLOCKED_REPLAY_CAVEMAN_CORRECTION = "CAVEMAN MODE - MANDATORY. SAME OPERATION BLOCKED. Do not repeat an unchanged operation. NEVER call it again with the same arguments in this run. This is not a harness loop or failure.";
-const CLOSED_OPERATION_CAVEMAN_CORRECTION = "CAVEMAN MODE - MANDATORY: OPERATION CLOSED; not executed. Do not repeat an unchanged operation. NEVER call it again with the same arguments in this run. Use a different operation/tool or continue independent work. The recovery guard prevented a loop; this is not harness failure.";
+const BLOCKED_REPLAY_CAVEMAN_CORRECTION = "Blocked: this exact operation will not run again this session — change the operation or continue other work.";
+const CLOSED_OPERATION_CAVEMAN_CORRECTION = "Closed: this exact operation was not executed and will not run again this session — use a different operation or continue other work.";
 function truncate(value, maxChars) {
     if (value.length <= maxChars)
         return value;
@@ -438,6 +438,19 @@ function boundedFailureCode(value) {
  * always the last line it appends — outranks any earlier, non-authoritative line that matches.
  */
 const EXIT_STATUS_LINE_PATTERN = /^(?:\S+\s+)?(?:exit(?:ed)?(?:\s+with)?(?:\s+code)?|exitcode)\s*[:=]?\s*(-?\d+)\b/i;
+/**
+ * bash.ts appends `cwd: <dir>` after its exit trailer on failures. The line is harness status, not
+ * a cause: it must never displace a real diagnostic (a path may contain words like "error"), and it
+ * reaches the model through the process-exit evidence tail instead.
+ */
+const CWD_STATUS_LINE_PATTERN = /^cwd:\s/i;
+/** Tool-owned status/marker lines that carry no cause and never belong in diagnostic or evidence. */
+function isFailureStatusLine(line) {
+    return (/^command (?:exited with code|timed out after|aborted|killed after)\b/i.test(line) ||
+        /^outcome:\s*(?:failed|aborted|timeout|output_limit)\b/i.test(line) ||
+        /^exitcode:\s*-?\d+\b/i.test(line) ||
+        /^(?:stdout|stderr):(?:\s*\(empty\))?$/i.test(line));
+}
 function processExitFailureCode(message) {
     const lines = message.split(/\r\n|\n/);
     for (let index = lines.length - 1; index >= 0; index--) {
@@ -522,7 +535,9 @@ function extractFailureDiagnostic(message, allowUnclassifiedFallback, requireStr
         const stderrLines = rawLines
             .slice(stderrMarkerIndex + 1)
             .map((line) => line.trim())
-            .filter((line) => line.length > 0 && !/^command (?:exited with code|timed out after|aborted|killed after)\b/i.test(line));
+            .filter((line) => line.length > 0 &&
+            !/^command (?:exited with code|timed out after|aborted|killed after)\b/i.test(line) &&
+            !CWD_STATUS_LINE_PATTERN.test(line));
         if (stderrLines.length > 0) {
             const classified = stderrLines.find((line) => strongDiagnosticPattern.test(line));
             if (classified)
@@ -539,11 +554,7 @@ function extractFailureDiagnostic(message, allowUnclassifiedFallback, requireStr
     }
     const lines = rawLines
         .map((line) => line.trim())
-        .filter((line) => line.length > 0 &&
-        !/^command (?:exited with code|timed out after|aborted|killed after)\b/i.test(line) &&
-        !/^outcome:\s*(?:failed|aborted|timeout|output_limit)\b/i.test(line) &&
-        !/^exitcode:\s*-?\d+\b/i.test(line) &&
-        !/^(?:stdout|stderr):(?:\s*\(empty\))?$/i.test(line));
+        .filter((line) => line.length > 0 && !isFailureStatusLine(line) && !CWD_STATUS_LINE_PATTERN.test(line));
     if (lines.length === 0)
         return undefined;
     const diagnosticPattern = requireStrongSignal
@@ -555,6 +566,35 @@ function extractFailureDiagnostic(message, allowUnclassifiedFallback, requireStr
     const diagnostic = classified ?? (allowUnclassifiedFallback ? lines.at(-1) : undefined);
     return diagnostic ? truncateMiddle(diagnostic, MAX_DIAGNOSTIC_CHARS) : undefined;
 }
+/**
+ * Bounded raw-output tail of an executed process-exit failure. Evidence is the raw-data channel:
+ * it keeps the trailing lines that strong-signal diagnostic classification refuses to promote, so
+ * strictness never destroys the output needed to construct a changed operation.
+ */
+function extractProcessExitEvidence(message) {
+    const lines = sanitizeBinaryOutput(message)
+        .replaceAll("\r\n", "\n")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !isFailureStatusLine(line));
+    if (lines.length === 0)
+        return undefined;
+    let start = lines.length - 1;
+    let retainedChars = lines[start].length;
+    while (start > 0 && retainedChars + 1 + lines[start - 1].length <= MAX_TOOL_FAILURE_EVIDENCE_CHARS) {
+        start--;
+        retainedChars += 1 + lines[start].length;
+    }
+    let tail = lines.slice(start).join("\n");
+    if (tail.length > MAX_TOOL_FAILURE_EVIDENCE_CHARS) {
+        let tailStart = tail.length - MAX_TOOL_FAILURE_EVIDENCE_CHARS;
+        const firstCode = tail.charCodeAt(tailStart);
+        if (firstCode >= 0xdc00 && firstCode <= 0xdfff)
+            tailStart++;
+        tail = tail.slice(tailStart);
+    }
+    return sanitizeToolFailureEvidence(tail);
+}
 export function assessToolFailure(message, state, errorClass) {
     const policy = getToolExecutionErrorPolicy(message);
     const exitFailureCode = processExitFailureCode(message);
@@ -562,14 +602,17 @@ export function assessToolFailure(message, state, errorClass) {
     const diagnostic = state === "failed" && (!policy || policy.retainDiagnostic)
         ? extractFailureDiagnostic(message, exitFailureCode === undefined && (errorClass !== undefined || retainPolicyDiagnostic), exitFailureCode !== undefined && !retainPolicyDiagnostic)
         : undefined;
+    const evidence = state === "failed" && exitFailureCode !== undefined ? extractProcessExitEvidence(message) : undefined;
     const failureCode = policy?.failureCode ?? classifyToolFailure(message, errorClass);
     return {
         failureCode,
         phase: policy?.phase ?? inferToolFailurePhase(state, failureCode),
         ...(diagnostic ? { diagnostic } : {}),
+        ...(evidence ? { evidence } : {}),
         guidance: policy
             ? truncate(policy.guidance, MAX_CORRECTION_CHARS)
             : fallbackFailureGuidance(state, diagnostic !== undefined, inferToolFailurePhase(state, failureCode)),
+        ...(policy ? { policyGuidance: truncate(policy.guidance, MAX_CORRECTION_CHARS) } : {}),
         ...(policy?.attemptMemory === "discard" ? { attemptMemory: "discard" } : {}),
     };
 }
@@ -592,6 +635,7 @@ function readFailureRecord(details) {
         return undefined;
     }
     const diagnostic = typeof candidate.diagnostic === "string" ? truncate(candidate.diagnostic, MAX_DIAGNOSTIC_CHARS) : undefined;
+    const note = typeof candidate.note === "string" ? truncate(candidate.note, MAX_DIAGNOSTIC_CHARS) : undefined;
     const evidence = sanitizeToolFailureEvidence(candidate.evidence);
     const retainedCorrection = typeof candidate.correction === "string" ? truncate(candidate.correction, MAX_CORRECTION_CHARS) : undefined;
     const correction = candidate.state === "failed" && retainedCorrection === LEGACY_GENERIC_EXECUTION_CORRECTION
@@ -616,6 +660,7 @@ function readFailureRecord(details) {
         phase,
         failureCode: boundedFailureCode(candidate.failureCode),
         diagnostic,
+        note,
         evidence,
         correction,
     };
@@ -925,6 +970,7 @@ function formatRecordJson(record, includeOperation = false, evidence = record.ev
         ...(includeOperation ? { operation: record.operation } : {}),
         failure_code: record.failureCode,
         ...(record.diagnostic ? { diagnostic: record.diagnostic } : {}),
+        ...(record.note ? { note: record.note } : {}),
         ...(evidence ? { evidence } : {}),
         ...guidance,
         ...(record.attemptMemory === "discard" ? { attempt_memory: "discarded" } : {}),
@@ -955,32 +1001,31 @@ export function createToolFailureResult(record, terminate) {
     };
 }
 export function createRepeatedToolFailureResult(record) {
-    const retainedRecord = {
-        ...retainBlockedToolFailure(record),
-        correction: BLOCKED_REPLAY_CAVEMAN_CORRECTION,
-    };
-    const diagnostic = truncateMiddle(`The unchanged operation was not executed. Unchanged replay blocked after ${record.failureCode}`, MAX_DIAGNOSTIC_CHARS);
+    const retainedRecord = retainBlockedToolFailure(record);
+    const replayNotice = truncateMiddle(`The unchanged operation was not executed. Unchanged replay blocked after ${record.failureCode}`, MAX_DIAGNOSTIC_CHARS);
     const blockedResult = createToolFailureResult({
         ...retainedRecord,
         state: "rejected",
         failureCode: "repeated_failed_operation",
-        diagnostic,
-        correction: retainedRecord.correction,
+        ...(retainedRecord.diagnostic
+            ? { note: replayNotice }
+            : { diagnostic: replayNotice, correction: BLOCKED_REPLAY_CAVEMAN_CORRECTION }),
     });
     return {
         ...blockedResult,
-        // The visible result describes this rejected replay, while retained memory keeps the
-        // authoritative cause so later blocks do not recursively wrap synthetic failures.
+        // The visible result leads with the retained root cause and carries the replay notice as a
+        // note, while retained memory keeps the authoritative cause so later blocks do not
+        // recursively wrap synthetic failures.
         details: { piToolFailureMemory: retainedRecord },
     };
 }
-export function createToolFailureRecoveryExhaustedResult(record, diagnostic) {
+export function createToolFailureRecoveryExhaustedResult(record, note) {
     const retainedRecord = retainBlockedToolFailure(record);
     const exhaustedResult = createToolFailureResult({
         ...retainedRecord,
         state: "rejected",
         failureCode: "recovery_exhausted",
-        diagnostic: truncateMiddle(diagnostic, MAX_DIAGNOSTIC_CHARS),
+        note: truncateMiddle(note, MAX_DIAGNOSTIC_CHARS),
         correction: "Stop retrying tools in this run. Report the unresolved failure and the user or environment action required to continue.",
     }, true);
     return {
@@ -988,7 +1033,7 @@ export function createToolFailureRecoveryExhaustedResult(record, diagnostic) {
         details: { piToolFailureMemory: retainedRecord },
     };
 }
-export function createToolFailureOperationExhaustedResult(record, diagnostic) {
+export function createToolFailureOperationExhaustedResult(record, note) {
     const retainedRecord = {
         ...retainBlockedToolFailure(record),
         correction: CLOSED_OPERATION_CAVEMAN_CORRECTION,
@@ -997,7 +1042,7 @@ export function createToolFailureOperationExhaustedResult(record, diagnostic) {
         ...retainedRecord,
         state: "rejected",
         failureCode: "operation_recovery_exhausted",
-        diagnostic: truncateMiddle(diagnostic, MAX_DIAGNOSTIC_CHARS),
+        note: truncateMiddle(note, MAX_DIAGNOSTIC_CHARS),
     }, false);
     return {
         ...exhaustedResult,