agent-inspect 6.26.0 → 6.28.0

package/packages/core/dist/checks.cjs

@@ -1462,6 +1462,133 @@ function evaluateControlRules(events, rules, runEvidence2, observationNames) {
   return findings;
 }
 
+// packages/core/src/checks/tool-arguments.ts
+function decodeToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function resolveJsonPointer(document, pointer) {
+  if (pointer === "") {
+    return { found: true, value: document };
+  }
+  if (!pointer.startsWith("/")) {
+    return { found: false };
+  }
+  const tokens = pointer.slice(1).split("/").map(decodeToken);
+  let current = document;
+  for (const token of tokens) {
+    if (current === null || current === void 0) {
+      return { found: false };
+    }
+    if (Array.isArray(current)) {
+      if (!/^(0|[1-9][0-9]*)$/.test(token)) {
+        return { found: false };
+      }
+      const index = Number(token);
+      if (index >= current.length) {
+        return { found: false };
+      }
+      current = current[index];
+      continue;
+    }
+    if (typeof current !== "object") {
+      return { found: false };
+    }
+    const record = current;
+    if (!Object.prototype.hasOwnProperty.call(record, token)) {
+      return { found: false };
+    }
+    current = record[token];
+  }
+  return { found: true, value: current };
+}
+function jsonType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function valuesEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function extractToolArgumentPayload(event) {
+  const attrs2 = event.attributes ?? {};
+  for (const key of ["arguments", "input", "toolArguments"]) {
+    const candidate = attrs2[key];
+    if (candidate !== void 0 && candidate !== null && typeof candidate === "object") {
+      return { present: true, value: candidate };
+    }
+  }
+  if (event.inputSummary !== void 0 && event.inputSummary !== null && typeof event.inputSummary === "object") {
+    return { present: true, value: event.inputSummary };
+  }
+  return { present: false, value: void 0 };
+}
+function evaluateToolArgumentValue(value, check, evidencePresent) {
+  if (!evidencePresent) {
+    return {
+      status: "unavailable",
+      code: "AI_CHECK_TOOL_ARGUMENT_EVIDENCE_UNAVAILABLE",
+      message: `Structured argument evidence unavailable for tool ${check.tool} at ${check.path}.`
+    };
+  }
+  const resolved = resolveJsonPointer(value, check.path);
+  if (check.operator === "exists") {
+    return resolved.found ? { status: "pass" } : {
+      status: "fail",
+      code: "AI_CHECK_TOOL_ARGUMENT_MISSING",
+      message: `Expected path ${check.path} to exist on tool ${check.tool}.`
+    };
+  }
+  if (!resolved.found) {
+    return {
+      status: "unavailable",
+      code: "AI_CHECK_TOOL_ARGUMENT_EVIDENCE_UNAVAILABLE",
+      message: `Path ${check.path} missing for tool ${check.tool}.`
+    };
+  }
+  if (check.operator === "type") {
+    const actual = jsonType(resolved.value);
+    if (check.type === void 0) {
+      return {
+        status: "fail",
+        code: "AI_CHECK_TOOL_ARGUMENT_INVALID_CONFIG",
+        message: "type operator requires check.type"
+      };
+    }
+    return actual === check.type ? { status: "pass" } : {
+      status: "fail",
+      code: "AI_CHECK_TOOL_ARGUMENT_TYPE",
+      message: `Expected type ${check.type} at ${check.path} for tool ${check.tool}; found ${actual}.`
+    };
+  }
+  if (check.operator === "equals") {
+    return valuesEqual(resolved.value, check.expected) ? { status: "pass" } : {
+      status: "fail",
+      code: "AI_CHECK_TOOL_ARGUMENT_EQUALS",
+      message: `Value at ${check.path} for tool ${check.tool} did not equal expected (bounded comparison).`
+    };
+  }
+  if (check.operator === "oneOf") {
+    const options = check.oneOf ?? [];
+    if (options.length === 0) {
+      return {
+        status: "fail",
+        code: "AI_CHECK_TOOL_ARGUMENT_INVALID_CONFIG",
+        message: "oneOf operator requires a non-empty oneOf array"
+      };
+    }
+    return options.some((option) => valuesEqual(resolved.value, option)) ? { status: "pass" } : {
+      status: "fail",
+      code: "AI_CHECK_TOOL_ARGUMENT_ONE_OF",
+      message: `Value at ${check.path} for tool ${check.tool} was not in the allowed oneOf set.`
+    };
+  }
+  return {
+    status: "fail",
+    code: "AI_CHECK_TOOL_ARGUMENT_INVALID_CONFIG",
+    message: `Unsupported operator.`
+  };
+}
+
 // packages/core/src/checks/retry-safety.ts
 function fail2(ruleId, message, evidence, expected, actual) {
   return {
@@ -1777,131 +1904,366 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
   return findings;
 }
 
-// packages/core/src/checks/tool-arguments.ts
-function decodeToken(token) {
-  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+// packages/core/src/checks/recovery-operations.ts
+function fail3(ruleId, message, evidence, expected, actual) {
+  return {
+    ruleId,
+    severity: "error",
+    status: "fail",
+    message,
+    ...expected !== void 0 ? { expected } : {},
+    ...actual !== void 0 ? { actual } : {},
+    evidence: [...evidence]
+  };
 }
-function resolveJsonPointer(document, pointer) {
-  if (pointer === "") {
-    return { found: true, value: document };
+function workflowFor2(event) {
+  const attrs2 = event.attributes;
+  if (!attrs2 || typeof attrs2 !== "object") return {};
+  const direct = extractSessionWorkflowMetadata(attrs2);
+  const nested = attrs2.metadata && typeof attrs2.metadata === "object" ? extractSessionWorkflowMetadata(attrs2.metadata) : void 0;
+  return { ...nested, ...direct };
+}
+function eventEvidence2(event) {
+  return {
+    runId: event.runId,
+    eventId: event.eventId,
+    kind: event.kind,
+    name: event.name,
+    status: event.status
+  };
+}
+function eventTime2(event) {
+  return event.startedAt ?? event.timestamp ?? "";
+}
+function sortByTime2(events) {
+  return [...events].sort((a, b) => eventTime2(a).localeCompare(eventTime2(b)));
+}
+function hasIdempotencyEvidence2(event) {
+  const workflow = workflowFor2(event);
+  if (typeof workflow.idempotencyKey === "string" && workflow.idempotencyKey.trim() !== "") {
+    return true;
   }
-  if (!pointer.startsWith("/")) {
-    return { found: false };
+  const attrs2 = event.attributes ?? {};
+  if (attrs2.noSideEffect === true) return true;
+  if (attrs2.sideEffect === false) return true;
+  return false;
+}
+function errorCodeOf(event) {
+  if (typeof event.error?.code === "string" && event.error.code.trim() !== "") {
+    return event.error.code.trim();
   }
-  const tokens = pointer.slice(1).split("/").map(decodeToken);
-  let current = document;
-  for (const token of tokens) {
-    if (current === null || current === void 0) {
-      return { found: false };
-    }
-    if (Array.isArray(current)) {
-      if (!/^(0|[1-9][0-9]*)$/.test(token)) {
-        return { found: false };
-      }
-      const index = Number(token);
-      if (index >= current.length) {
-        return { found: false };
-      }
-      current = current[index];
-      continue;
-    }
-    if (typeof current !== "object") {
-      return { found: false };
-    }
-    const record = current;
-    if (!Object.prototype.hasOwnProperty.call(record, token)) {
-      return { found: false };
-    }
-    current = record[token];
+  const attrs2 = event.attributes ?? {};
+  for (const key of ["errorCode", "code"]) {
+    const value = attrs2[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
   }
-  return { found: true, value: current };
-}
-function jsonType(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  return typeof value;
-}
-function valuesEqual(left, right) {
-  return JSON.stringify(left) === JSON.stringify(right);
+  const nested = attrs2.error;
+  if (nested && typeof nested === "object") {
+    const code = nested.code;
+    if (typeof code === "string" && code.trim() !== "") return code.trim();
+  }
+  return void 0;
 }
-function extractToolArgumentPayload(event) {
+function argumentDigestOf(event) {
   const attrs2 = event.attributes ?? {};
-  for (const key of ["arguments", "input", "toolArguments"]) {
-    const candidate = attrs2[key];
-    if (candidate !== void 0 && candidate !== null && typeof candidate === "object") {
-      return { present: true, value: candidate };
-    }
+  for (const key of ["argumentsDigest", "inputDigest", "toolArgumentsDigest"]) {
+    const value = attrs2[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
   }
-  if (event.inputSummary !== void 0 && event.inputSummary !== null && typeof event.inputSummary === "object") {
-    return { present: true, value: event.inputSummary };
+  const commitment = attrs2.omittedPayloadCommitment;
+  if (commitment && typeof commitment === "object") {
+    const digest = commitment.digest;
+    if (typeof digest === "string" && digest.trim() !== "") return digest.trim();
   }
-  return { present: false, value: void 0 };
+  return void 0;
 }
-function evaluateToolArgumentValue(value, check, evidencePresent) {
-  if (!evidencePresent) {
+function argumentFingerprint(event) {
+  const payload = extractToolArgumentPayload(event);
+  if (payload.present) {
+    try {
+      return { kind: "structured", value: JSON.stringify(payload.value) };
+    } catch {
+      return { kind: "missing" };
+    }
+  }
+  const digest = argumentDigestOf(event);
+  if (digest) return { kind: "digest", value: digest };
+  return { kind: "missing" };
+}
+function sameArguments(left, right) {
+  const a = argumentFingerprint(left);
+  const b = argumentFingerprint(right);
+  if (a.kind === "missing" || b.kind === "missing") {
     return {
-      status: "unavailable",
-      code: "AI_CHECK_TOOL_ARGUMENT_EVIDENCE_UNAVAILABLE",
-      message: `Structured argument evidence unavailable for tool ${check.tool} at ${check.path}.`
+      ok: false,
+      reason: "Structured or digest argument evidence unavailable for same-arguments check.",
+      code: "AI_CHECK_RECOVERY_ARGUMENT_EVIDENCE_UNAVAILABLE"
     };
   }
-  const resolved = resolveJsonPointer(value, check.path);
-  if (check.operator === "exists") {
-    return resolved.found ? { status: "pass" } : {
-      status: "fail",
-      code: "AI_CHECK_TOOL_ARGUMENT_MISSING",
-      message: `Expected path ${check.path} to exist on tool ${check.tool}.`
+  if (a.kind !== b.kind) {
+    return {
+      ok: false,
+      reason: "Argument evidence kinds differ across attempts (structured vs digest).",
+      code: "AI_CHECK_RECOVERY_ARGUMENT_EVIDENCE_MISMATCH"
     };
   }
-  if (!resolved.found) {
+  if (a.value !== b.value) {
     return {
-      status: "unavailable",
-      code: "AI_CHECK_TOOL_ARGUMENT_EVIDENCE_UNAVAILABLE",
-      message: `Path ${check.path} missing for tool ${check.tool}.`
+      ok: false,
+      reason: "Retry arguments do not match prior attempt.",
+      code: "AI_CHECK_RECOVERY_ARGUMENTS_DIFFER"
     };
   }
-  if (check.operator === "type") {
-    const actual = jsonType(resolved.value);
-    if (check.type === void 0) {
-      return {
-        status: "fail",
-        code: "AI_CHECK_TOOL_ARGUMENT_INVALID_CONFIG",
-        message: "type operator requires check.type"
-      };
+  return { ok: true };
+}
+function isUnevaluableWriteCompletion(event) {
+  if (event.status === "running" || event.status === "unknown") return true;
+  const attrs2 = event.attributes ?? {};
+  if (attrs2.timeout === true) return true;
+  if (attrs2.completionState === "unknown" || attrs2.completionState === "timeout") return true;
+  const code = errorCodeOf(event)?.toUpperCase();
+  if (code === "TIMEOUT" || code === "UNKNOWN_COMPLETION" || code === "DEADLINE_EXCEEDED") {
+    return true;
+  }
+  return false;
+}
+function collectExplicitReferences(event) {
+  const refs = /* @__PURE__ */ new Set();
+  const attrs2 = event.attributes ?? {};
+  const candidates = [
+    attrs2.referencedEventId,
+    attrs2.referencedEventIds,
+    attrs2.toolResultEventId,
+    attrs2.toolResultEventIds,
+    attrs2.inputEventIds,
+    attrs2.dependsOnEventIds,
+    attrs2.evidence,
+    workflowFor2(event).toolCallId
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim() !== "") {
+      refs.add(candidate.trim());
+      continue;
+    }
+    if (Array.isArray(candidate)) {
+      for (const item of candidate) {
+        if (typeof item === "string" && item.trim() !== "") refs.add(item.trim());
+        if (item && typeof item === "object") {
+          const id = item.eventId;
+          if (typeof id === "string" && id.trim() !== "") refs.add(id.trim());
+        }
+      }
+      continue;
+    }
+    if (candidate && typeof candidate === "object") {
+      const obj = candidate;
+      if (typeof obj.eventId === "string" && obj.eventId.trim() !== "") {
+        refs.add(obj.eventId.trim());
+      }
+      if (Array.isArray(obj.eventIds)) {
+        for (const id of obj.eventIds) {
+          if (typeof id === "string" && id.trim() !== "") refs.add(id.trim());
+        }
+      }
     }
-    return actual === check.type ? { status: "pass" } : {
-      status: "fail",
-      code: "AI_CHECK_TOOL_ARGUMENT_TYPE",
-      message: `Expected type ${check.type} at ${check.path} for tool ${check.tool}; found ${actual}.`
-    };
   }
-  if (check.operator === "equals") {
-    return valuesEqual(resolved.value, check.expected) ? { status: "pass" } : {
-      status: "fail",
-      code: "AI_CHECK_TOOL_ARGUMENT_EQUALS",
-      message: `Value at ${check.path} for tool ${check.tool} did not equal expected (bounded comparison).`
-    };
+  return refs;
+}
+function llmReferencesTool(llm, toolEvent, requireExplicit) {
+  if (!requireExplicit) {
+    return eventTime2(llm) >= eventTime2(toolEvent);
   }
-  if (check.operator === "oneOf") {
-    const options = check.oneOf ?? [];
-    if (options.length === 0) {
-      return {
-        status: "fail",
-        code: "AI_CHECK_TOOL_ARGUMENT_INVALID_CONFIG",
-        message: "oneOf operator requires a non-empty oneOf array"
-      };
+  const refs = collectExplicitReferences(llm);
+  if (refs.has(toolEvent.eventId)) return true;
+  const toolCallId = workflowFor2(toolEvent).toolCallId;
+  if (toolCallId && refs.has(toolCallId)) return true;
+  return false;
+}
+function groupToolAttempts(events, toolName2) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.kind !== "TOOL") continue;
+    if (resolveCanonicalToolName(event) !== toolName2) continue;
+    const workflow = workflowFor2(event);
+    const key = workflow.operationId ?? `__tool__:${toolName2}`;
+    const list = groups.get(key) ?? [];
+    list.push(event);
+    groups.set(key, list);
+  }
+  return groups;
+}
+function evaluateRecoveryOperations(events, operations) {
+  const findings = [];
+  const llmEvents = events.filter((event) => event.kind === "LLM");
+  for (const operation of operations) {
+    const sideEffectClass = operation.sideEffectClass ?? "read";
+    const groups = groupToolAttempts(events, operation.tool);
+    if (groups.size === 0) {
+      if (operation.requireTerminalSuccess) {
+        findings.push(
+          fail3(
+            "contract.retry.operations.terminal-success",
+            `Recovery operation for tool ${operation.tool} requires a terminal success but no attempts were observed.`,
+            [],
+            "ok",
+            "missing"
+          )
+        );
+      }
+      continue;
+    }
+    for (const [operationKey, members] of groups) {
+      const ordered = sortByTime2(members);
+      if (operation.maxAttempts !== void 0) {
+        const count = countOperationAttempts(members);
+        if (count > operation.maxAttempts) {
+          findings.push(
+            fail3(
+              "contract.retry.operations.max-attempts",
+              `Tool ${operation.tool} operation ${operationKey} exceeded maxAttempts ${operation.maxAttempts}.`,
+              members.slice(0, 4).map(eventEvidence2),
+              operation.maxAttempts,
+              count
+            )
+          );
+        }
+      }
+      if (sideEffectClass === "write") {
+        for (const event of ordered) {
+          if (isUnevaluableWriteCompletion(event) && !hasIdempotencyEvidence2(event)) {
+            findings.push(
+              fail3(
+                "contract.retry.operations.write-completion-unevaluable",
+                `Write tool ${operation.tool} has timeout/unknown completion without authoritative idempotency evidence.`,
+                [eventEvidence2(event)],
+                "idempotencyKey|authoritative completion",
+                {
+                  code: "AI_CHECK_RECOVERY_WRITE_COMPLETION_UNAVAILABLE",
+                  status: event.status
+                }
+              )
+            );
+          }
+        }
+      }
+      const prior = [];
+      let sawEarlierError = false;
+      let sawLaterOkAfterError = false;
+      let lastOk;
+      for (const event of ordered) {
+        const classification = classifyRetryAttempt(event, prior, members);
+        const isRetry = classification.kind === "retry";
+        if (isRetry && operation.requireFailureBeforeRetry) {
+          const earlierFailure = prior.some(
+            (candidate) => candidate.status === "error" && eventTime2(candidate) !== "" && eventTime2(event) !== "" && eventTime2(candidate) < eventTime2(event)
+          );
+          if (!earlierFailure) {
+            findings.push(
+              fail3(
+                "contract.retry.operations.failure-before-retry",
+                `Retry of tool ${operation.tool} appeared without an earlier failure in the same operation.`,
+                [eventEvidence2(event)],
+                "earlier error attempt",
+                { operationKey }
+              )
+            );
+          }
+        }
+        if (isRetry && operation.retryableErrors?.codes && operation.retryableErrors.codes.length > 0) {
+          const allowed = new Set(operation.retryableErrors.codes);
+          const priorErrors = prior.filter((candidate) => candidate.status === "error");
+          const lastError = priorErrors[priorErrors.length - 1];
+          if (lastError) {
+            const code = errorCodeOf(lastError);
+            if (!code || !allowed.has(code)) {
+              findings.push(
+                fail3(
+                  "contract.retry.operations.retryable-error",
+                  `Retry of tool ${operation.tool} followed a non-retryable or missing error code.`,
+                  [eventEvidence2(event), eventEvidence2(lastError)],
+                  [...allowed],
+                  code ?? null
+                )
+              );
+            }
+          }
+        }
+        if (isRetry && (operation.requireSameArguments === true || operation.requireSameArguments === "structured-or-digest")) {
+          const baseline = prior[0] ?? prior[prior.length - 1];
+          if (baseline) {
+            const comparison = sameArguments(baseline, event);
+            if (!comparison.ok) {
+              findings.push(
+                fail3(
+                  "contract.retry.operations.same-arguments",
+                  comparison.reason,
+                  [eventEvidence2(baseline), eventEvidence2(event)],
+                  "matching structured args or digests",
+                  { code: comparison.code }
+                )
+              );
+            }
+          }
+        }
+        if (event.status === "error") {
+          sawEarlierError = true;
+        } else if (event.status === "ok" && sawEarlierError) {
+          sawLaterOkAfterError = true;
+        }
+        if (event.status === "ok") {
+          lastOk = event;
+        }
+        prior.push(event);
+      }
+      if (operation.requireTerminalSuccess) {
+        const hasOk = ordered.some((event) => event.status === "ok");
+        if (!hasOk) {
+          findings.push(
+            fail3(
+              "contract.retry.operations.terminal-success",
+              `Tool ${operation.tool} operation ${operationKey} has no terminal ok success.`,
+              ordered.slice(0, 4).map(eventEvidence2),
+              "ok",
+              ordered.map((event) => event.status)
+            )
+          );
+        }
+      }
+      if (operation.requireRecoveredFailureVisible) {
+        const hasOk = ordered.some((event) => event.status === "ok");
+        if (ordered.length > 1 && hasOk && !sawLaterOkAfterError) {
+          findings.push(
+            fail3(
+              "contract.retry.operations.recovered-failure-visible",
+              `Tool ${operation.tool} operation ${operationKey} does not show an earlier error before later success.`,
+              ordered.slice(0, 4).map(eventEvidence2),
+              "earlier error then later ok",
+              { sawEarlierError }
+            )
+          );
+        }
+      }
+      const dependency = operation.successfulResultDependency;
+      if (dependency?.consumerKind === "LLM" && lastOk) {
+        const requireExplicit = dependency.requireExplicitReference === true;
+        const referenced = llmEvents.some(
+          (llmEvent) => llmReferencesTool(llmEvent, lastOk, requireExplicit)
+        );
+        if (!referenced) {
+          findings.push(
+            fail3(
+              "contract.retry.operations.successful-result-dependency",
+              requireExplicit ? `Successful ${operation.tool} result is not explicitly referenced by a later LLM event.` : `Successful ${operation.tool} result has no later LLM consumer.`,
+              [eventEvidence2(lastOk)],
+              "LLM reference to successful tool event",
+              { code: "AI_CHECK_RECOVERY_RESULT_DEPENDENCY_MISSING" }
+            )
+          );
+        }
+      }
     }
-    return options.some((option) => valuesEqual(resolved.value, option)) ? { status: "pass" } : {
-      status: "fail",
-      code: "AI_CHECK_TOOL_ARGUMENT_ONE_OF",
-      message: `Value at ${check.path} for tool ${check.tool} was not in the allowed oneOf set.`
-    };
   }
-  return {
-    status: "fail",
-    code: "AI_CHECK_TOOL_ARGUMENT_INVALID_CONFIG",
-    message: `Unsupported operator.`
-  };
+  return findings;
 }
 
 // packages/core/src/checks/contract.ts
@@ -1950,7 +2312,23 @@ function cloneBody(body) {
     ...body.retry ? {
       retry: {
         ...body.retry,
-        ...body.retry.nonIdempotentTools ? { nonIdempotentTools: [...body.retry.nonIdempotentTools] } : {}
+        ...body.retry.nonIdempotentTools ? { nonIdempotentTools: [...body.retry.nonIdempotentTools] } : {},
+        ...body.retry.operations ? {
+          operations: body.retry.operations.map((operation) => ({
+            ...operation,
+            ...operation.retryableErrors ? {
+              retryableErrors: {
+                ...operation.retryableErrors,
+                ...operation.retryableErrors.codes ? { codes: [...operation.retryableErrors.codes] } : {}
+              }
+            } : {},
+            ...operation.successfulResultDependency ? {
+              successfulResultDependency: {
+                ...operation.successfulResultDependency
+              }
+            } : {}
+          }))
+        } : {}
       }
     } : {}
   };
@@ -2385,7 +2763,11 @@ function contractToRules(contract) {
             name: context.selectedRun.name
           }
         ] : [];
-        return evaluateRetrySafetyRules(events, retry);
+        const base = evaluateRetrySafetyRules(events, retry);
+        if (!retry.operations || retry.operations.length === 0) {
+          return base;
+        }
+        return [...base, ...evaluateRecoveryOperations(events, retry.operations)];
       }
     });
   }
@@ -2870,7 +3252,10 @@ function explainTraceContract(contract) {
     lines.push("Base: declared-versus-enforced control checks enabled.");
   }
   if (contract.retry) {
-    lines.push("Base: retry/side-effect safety checks enabled.");
+    const opCount = contract.retry.operations?.length ?? 0;
+    lines.push(
+      opCount > 0 ? `Base: retry/side-effect safety checks enabled (${opCount} recovery operation oracle(s)).` : "Base: retry/side-effect safety checks enabled."
+    );
   }
   const branches = contract.alternatives?.anyOf ?? [];
   if (branches.length > 0) {
@@ -3221,7 +3606,7 @@ function stripPrefix(name, prefixes) {
   }
   return name;
 }
-function eventEvidence2(event, path3) {
+function eventEvidence3(event, path3) {
   return {
     runId: event.runId,
     eventId: event.eventId,
@@ -3491,7 +3876,7 @@ function guardrailShape(context) {
 }
 function firstEvidenceForKind(context, kind, path3) {
   const event = semanticEvents(context).find((candidate) => candidate.kind === kind);
-  return event ? [eventEvidence2(event, path3)] : runEvidence(context.selectedRun);
+  return event ? [eventEvidence3(event, path3)] : runEvidence(context.selectedRun);
 }
 function baselineDiffFinding(message, evidence, expected, actual) {
   return failFinding("baseline.regression", message, evidence, expected, actual);
@@ -3524,7 +3909,7 @@ function createRunStatusRule(options = {}) {
             failFinding(
               "run.status",
               "Run contains incomplete running events.",
-              running.map((event) => eventEvidence2(event)),
+              running.map((event) => eventEvidence3(event)),
               "no running events",
               running.length
             )
@@ -3570,7 +3955,7 @@ function createMaxStepDurationRule(options) {
         failFinding(
           "run.maxStepDuration",
           `${over.length} step(s) exceeded max duration ${options.maxDurationMs}ms.`,
-          over.map((event) => eventEvidence2(event, "durationMs")),
+          over.map((event) => eventEvidence3(event, "durationMs")),
           { maxDurationMs: options.maxDurationMs },
           over.map((event) => ({
             eventId: event.eventId,
@@ -3596,7 +3981,7 @@ function createStallDetectionRule(options = {}) {
           failFinding(
             "run.stall",
             `Found ${running.length} event(s) still running (possible stall).`,
-            running.map((event) => eventEvidence2(event, "status")),
+            running.map((event) => eventEvidence3(event, "status")),
             "no running events",
             running.length
           )
@@ -3611,7 +3996,7 @@ function createStallDetectionRule(options = {}) {
             failFinding(
               "run.stall",
               `Found ${incomplete.length} started event(s) without endedAt.`,
-              incomplete.map((event) => eventEvidence2(event, "endedAt")),
+              incomplete.map((event) => eventEvidence3(event, "endedAt")),
               "endedAt for started events",
               incomplete.length
             )
@@ -3647,7 +4032,7 @@ function createRequireCompletedRule() {
           failFinding(
             "run.requireCompleted",
             `Run has ${running.length} incomplete running event(s).`,
-            running.map((event) => eventEvidence2(event, "status")),
+            running.map((event) => eventEvidence3(event, "status")),
             "no running events",
             running.length
           )
@@ -3745,12 +4130,12 @@ function createToolUsageRule(options) {
         const name = toolName(event);
         if (forbidden.has(name)) {
           findings.push(
-            failFinding("tool.usage", `Forbidden tool ${name} appeared.`, [eventEvidence2(event)], "tool absent", name)
+            failFinding("tool.usage", `Forbidden tool ${name} appeared.`, [eventEvidence3(event)], "tool absent", name)
           );
         }
         if (allowed && !allowed.has(name)) {
           findings.push(
-            failFinding("tool.usage", `Tool ${name} is not in the allowed tool set.`, [eventEvidence2(event)], [...allowed].sort(), name)
+            failFinding("tool.usage", `Tool ${name} is not in the allowed tool set.`, [eventEvidence3(event)], [...allowed].sort(), name)
           );
         }
       }
@@ -3761,7 +4146,7 @@ function createToolUsageRule(options) {
       }
       if (options.maxCount !== void 0 && tools.length > options.maxCount) {
         findings.push(
-          failFinding("tool.usage", `Tool count ${tools.length} exceeded maximum ${options.maxCount}.`, tools.map((event) => eventEvidence2(event)), { maxCount: options.maxCount }, tools.length)
+          failFinding("tool.usage", `Tool count ${tools.length} exceeded maximum ${options.maxCount}.`, tools.map((event) => eventEvidence3(event)), { maxCount: options.maxCount }, tools.length)
         );
       }
       return findings;
@@ -3788,7 +4173,7 @@ function createToolOrderingRule(options) {
           failFinding(
             ruleId,
             `Tool ${options.before} must appear before ${options.after}.`,
-            [eventEvidence2(tools[beforeIndex]), eventEvidence2(tools[afterIndex])],
+            [eventEvidence3(tools[beforeIndex]), eventEvidence3(tools[afterIndex])],
             { before: options.before, after: options.after },
             tools.map(toolName)
           )
@@ -3810,7 +4195,7 @@ function createToolOrderingRule(options) {
             failFinding(
               ruleId,
               `Tool ${options.before} cannot causally happen before itself.`,
-              [eventEvidence2(beforeEvent)],
+              [eventEvidence3(beforeEvent)],
               expected,
               { code: "tool.order.same-tool" }
             )
@@ -3821,7 +4206,7 @@ function createToolOrderingRule(options) {
             failFinding(
               ruleId,
               `Tool order ${options.before} before ${options.after} could not establish causal timing.`,
-              [eventEvidence2(beforeEvent), eventEvidence2(afterEvent)],
+              [eventEvidence3(beforeEvent), eventEvidence3(afterEvent)],
               expected,
               {
                 code: "tool.order.interval-unresolved",
@@ -3836,7 +4221,7 @@ function createToolOrderingRule(options) {
             failFinding(
               ruleId,
               `Tool ${options.before} must finish before ${options.after} starts.`,
-              [eventEvidence2(beforeEvent), eventEvidence2(afterEvent)],
+              [eventEvidence3(beforeEvent), eventEvidence3(afterEvent)],
               expected,
               {
                 beforeEndedAt: new Date(beforeEnd).toISOString(),
@@ -3861,7 +4246,7 @@ function createToolOrderingRule(options) {
             failFinding(
               ruleId,
               `Tool ${options.before} cannot causally happen before itself.`,
-              [eventEvidence2(beforeEvent)],
+              [eventEvidence3(beforeEvent)],
               expected,
               { code: "tool.order.same-tool" }
             )
@@ -3896,7 +4281,7 @@ function createToolOrderingRule(options) {
             failFinding(
               ruleId,
               `Tool order ${options.before} before ${options.after} could not establish all causal intervals.`,
-              [firstMissingBefore, firstMissingAfter].filter((event) => event !== void 0).map((event) => eventEvidence2(event)),
+              [firstMissingBefore, firstMissingAfter].filter((event) => event !== void 0).map((event) => eventEvidence3(event)),
               expected,
               {
                 code: "tool.order.interval-unresolved",
@@ -3911,7 +4296,7 @@ function createToolOrderingRule(options) {
             failFinding(
               ruleId,
               `Every ${options.before} tool call must finish before any ${options.after} tool call starts.`,
-              [eventEvidence2(latestBefore.event), eventEvidence2(earliestAfter.event)],
+              [eventEvidence3(latestBefore.event), eventEvidence3(earliestAfter.event)],
               expected,
               {
                 latestBeforeEndedAt: new Date(latestBefore.end).toISOString(),
@@ -3935,7 +4320,7 @@ function createToolOrderingRule(options) {
               beforeEndedAt: beforeEvent.endedAt,
               afterStartedAt: afterEvent.startedAt ?? afterEvent.timestamp
             },
-            evidence: [eventEvidence2(beforeEvent), eventEvidence2(afterEvent)]
+            evidence: [eventEvidence3(beforeEvent), eventEvidence3(afterEvent)]
           }
         ];
       }
@@ -3958,7 +4343,7 @@ function createToolFailureRule(options) {
           failFinding(
             "tool.failures",
             `Tool failure count ${failures.length} exceeded ${options.maxFailures}.`,
-            failures.map((event) => eventEvidence2(event)),
+            failures.map((event) => eventEvidence3(event)),
             { maxFailures: options.maxFailures },
             failures.length
           )
@@ -3971,7 +4356,7 @@ function createToolFailureRule(options) {
             failFinding(
               "tool.failures",
               `Tool retry count exceeded ${options.maxRetries}.`,
-              excessiveRetries.map((item) => eventEvidence2(item.event, "attributes.retryCount")),
+              excessiveRetries.map((item) => eventEvidence3(item.event, "attributes.retryCount")),
               { maxRetries: options.maxRetries },
               excessiveRetries.map((item) => ({ tool: toolName(item.event), retries: item.count }))
             )
@@ -3998,7 +4383,7 @@ function createLlmUsageRule(options) {
           failFinding(
             "llm.usage",
             `LLM call count ${llms.length} exceeded ${options.maxCalls}.`,
-            llms.map((event) => eventEvidence2(event)),
+            llms.map((event) => eventEvidence3(event)),
             { maxCalls: options.maxCalls },
             llms.length
           )
@@ -4010,17 +4395,17 @@ function createLlmUsageRule(options) {
         const finishReason = llmFinishReason(event);
         if (allowedModels && (!model || !allowedModels.has(model))) {
           findings.push(
-            failFinding("llm.usage", `LLM model ${model ?? "unknown"} is not allowed.`, [eventEvidence2(event, "attributes.model")], [...allowedModels].sort(), model ?? "unknown")
+            failFinding("llm.usage", `LLM model ${model ?? "unknown"} is not allowed.`, [eventEvidence3(event, "attributes.model")], [...allowedModels].sort(), model ?? "unknown")
           );
         }
         if (allowedProviders && (!provider || !allowedProviders.has(provider))) {
           findings.push(
-            failFinding("llm.usage", `LLM provider ${provider ?? "unknown"} is not allowed.`, [eventEvidence2(event, "attributes.provider")], [...allowedProviders].sort(), provider ?? "unknown")
+            failFinding("llm.usage", `LLM provider ${provider ?? "unknown"} is not allowed.`, [eventEvidence3(event, "attributes.provider")], [...allowedProviders].sort(), provider ?? "unknown")
           );
         }
         if (finishReasons && (!finishReason || !finishReasons.has(finishReason))) {
           findings.push(
-            failFinding("llm.usage", `LLM finish reason ${finishReason ?? "unknown"} is not allowed.`, [eventEvidence2(event, "attributes.finishReason")], [...finishReasons].sort(), finishReason ?? "unknown")
+            failFinding("llm.usage", `LLM finish reason ${finishReason ?? "unknown"} is not allowed.`, [eventEvidence3(event, "attributes.finishReason")], [...finishReasons].sort(), finishReason ?? "unknown")
           );
         }
       }
@@ -4045,7 +4430,7 @@ function createLlmUsageRule(options) {
             failFinding(
               "llm.usage",
               `LLM ${key} token count ${tokenTotals[key]} exceeded ${limit}.`,
-              llms.map((event) => eventEvidence2(event, `tokenUsage.${key}`)),
+              llms.map((event) => eventEvidence3(event, `tokenUsage.${key}`)),
               { [`max${key[0].toUpperCase()}${key.slice(1)}Tokens`]: limit },
               tokenTotals[key]
             )
@@ -4070,7 +4455,7 @@ function createStructureIncompleteRule(options = {}) {
             failFinding(
               "structure.incomplete",
               "Trace contains incomplete running events.",
-              running.map((event) => eventEvidence2(event, "status")),
+              running.map((event) => eventEvidence3(event, "status")),
               "no running events",
               running.length
             )
@@ -4086,7 +4471,7 @@ function createStructureIncompleteRule(options = {}) {
             failFinding(
               "structure.incomplete",
               "Trace contains events with startedAt but no endedAt.",
-              missingEndedAt.map((event) => eventEvidence2(event, "endedAt")),
+              missingEndedAt.map((event) => eventEvidence3(event, "endedAt")),
               "endedAt for started events",
               missingEndedAt.length
             )
@@ -4114,7 +4499,7 @@ function createStructureOrphanRule(options = {}) {
         failFinding(
           "structure.orphan",
           "Trace contains events whose parentId is not present in the selected run.",
-          orphans.map((event) => eventEvidence2(event, "parentId")),
+          orphans.map((event) => eventEvidence3(event, "parentId")),
           "parentId resolves to an event in the selected run",
           orphans.length
         )
@@ -4146,7 +4531,7 @@ function createStructureCycleRule() {
                 failFinding(
                   "structure.cycle",
                   formatProgrammaticDiagnostic("AI_TRACE_RELATIONSHIP_CYCLE"),
-                  cycle.map((item) => eventEvidence2(item, "parentId")),
+                  cycle.map((item) => eventEvidence3(item, "parentId")),
                   "acyclic parentId graph",
                   cycle.map((item) => item.eventId).sort()
                 )
@@ -4178,7 +4563,7 @@ function createStructureRelationshipRule(options = {}) {
             failFinding(
               "structure.relationship",
               `Event confidence ${event.confidence} is below ${minConfidence}.`,
-              [eventEvidence2(event, "confidence")],
+              [eventEvidence3(event, "confidence")],
               { minConfidence },
               event.confidence
             )
@@ -4190,7 +4575,7 @@ function createStructureRelationshipRule(options = {}) {
             failFinding(
               "structure.relationship",
               "Event parentId points to itself.",
-              [eventEvidence2(event, "parentId")],
+              [eventEvidence3(event, "parentId")],
               "parentId references a distinct event",
               "self"
             )
@@ -4207,7 +4592,7 @@ function createStructureRelationshipRule(options = {}) {
               failFinding(
                 "structure.relationship",
                 "Parent event starts after child event.",
-                [eventEvidence2(parent), eventEvidence2(event, "parentId")],
+                [eventEvidence3(parent), eventEvidence3(event, "parentId")],
                 "parent start <= child start",
                 { parentEventId: parent.eventId, childEventId: event.eventId }
               )
@@ -4221,7 +4606,7 @@ function createStructureRelationshipRule(options = {}) {
               failFinding(
                 "structure.relationship",
                 "Trace parentSpanId does not match parent spanId.",
-                [eventEvidence2(event, "trace.parentSpanId")],
+                [eventEvidence3(event, "trace.parentSpanId")],
                 { parentSpanId: parent.trace.spanId },
                 actual ?? "missing"
               )
@@ -4250,7 +4635,7 @@ function createStructureParallelWidthRule(options) {
               "structure.parallelWidth",
               `Parent ${parentId} has ${children.length} children, exceeding ${options.maxChildren}.`,
               [
-                ...parent ? [eventEvidence2(parent)] : [{ runId: context.selectedRun?.runId, eventId: parentId }],
+                ...parent ? [eventEvidence3(parent)] : [{ runId: context.selectedRun?.runId, eventId: parentId }],
                 ...children.map((child) => ({
                   runId: child.event.runId,
                   eventId: child.event.eventId,
@@ -4298,7 +4683,7 @@ function createStructureParallelWidthRule(options) {
             failFinding(
               "structure.parallelWidth",
               `Concurrent event width ${maxActive.length} exceeded ${options.maxConcurrent}.`,
-              maxActive.map((event) => eventEvidence2(event)),
+              maxActive.map((event) => eventEvidence3(event)),
               { maxConcurrent: options.maxConcurrent },
               maxActive.length
             )
@@ -4341,7 +4726,7 @@ function createSignalRule(ruleId, label, options, selectEvents, nameForEvent) {
             failFinding(
               ruleId,
               `Forbidden ${label} ${name} appeared.`,
-              [eventEvidence2(event)],
+              [eventEvidence3(event)],
               `${label} absent`,
               name
             )
@@ -4352,7 +4737,7 @@ function createSignalRule(ruleId, label, options, selectEvents, nameForEvent) {
             failFinding(
               ruleId,
               `${label[0].toUpperCase()}${label.slice(1)} ${name} is not in the allowed set.`,
-              [eventEvidence2(event)],
+              [eventEvidence3(event)],
               [...allowed].sort(),
               name
             )
@@ -4375,7 +4760,7 @@ function createSignalRule(ruleId, label, options, selectEvents, nameForEvent) {
           failFinding(
             ruleId,
             `${label[0].toUpperCase()}${label.slice(1)} count ${events.length} exceeded maximum ${options.maxCount}.`,
-            events.map((event) => eventEvidence2(event)),
+            events.map((event) => eventEvidence3(event)),
             { maxCount: options.maxCount },
             events.length
           )
@@ -4429,7 +4814,7 @@ function createSafetyRedactionRule(options = {}) {
             failFinding(
               "safety.redaction",
               `Sensitive-looking field at ${entry.path} is not redacted.`,
-              [eventEvidence2(event, entry.path)],
+              [eventEvidence3(event, entry.path)],
               "redaction marker",
               { path: entry.path, valueType: valueType(entry.value) },
               {
@@ -4463,7 +4848,7 @@ function createSafetyRawContentRule(options = {}) {
             failFinding(
               "safety.rawPrompt",
               `Raw content-like field ${entry.path} is present.`,
-              [eventEvidence2(event, entry.path)],
+              [eventEvidence3(event, entry.path)],
               "metadata-only trace fields",
               { path: entry.path, valueType: valueType(entry.value) },
               {
@@ -4501,7 +4886,7 @@ function createSafetySecretPatternRule(options = {}) {
               failFinding(
                 "safety.secretPattern",
                 `Secret-like pattern ${pattern.id} matched at ${entry.path}.`,
-                [eventEvidence2(event, entry.path)],
+                [eventEvidence3(event, entry.path)],
                 "no secret-like strings",
                 { pattern: pattern.id, path: entry.path },
                 {
@@ -4534,7 +4919,7 @@ function createSafetyOversizedAttributeRule(options) {
               failFinding(
                 "safety.oversizedAttribute",
                 `String at ${entry.path} exceeds ${options.maxStringLength} characters.`,
-                [eventEvidence2(event, entry.path)],
+                [eventEvidence3(event, entry.path)],
                 { maxStringLength: options.maxStringLength },
                 { path: entry.path, length: entry.value.length },
                 {
@@ -4551,7 +4936,7 @@ function createSafetyOversizedAttributeRule(options) {
               failFinding(
                 "safety.oversizedAttribute",
                 `Array at ${entry.path} exceeds ${options.maxArrayLength} items.`,
-                [eventEvidence2(event, entry.path)],
+                [eventEvidence3(event, entry.path)],
                 { maxArrayLength: options.maxArrayLength },
                 { path: entry.path, length: entry.value.length },
                 {
@@ -4568,7 +4953,7 @@ function createSafetyOversizedAttributeRule(options) {
               failFinding(
                 "safety.oversizedAttribute",
                 `Object at ${entry.path} exceeds ${options.maxObjectKeys} keys.`,
-                [eventEvidence2(event, entry.path)],
+                [eventEvidence3(event, entry.path)],
                 { maxObjectKeys: options.maxObjectKeys },
                 { path: entry.path, keys: Object.keys(entry.value).length },
                 {
@@ -4587,7 +4972,7 @@ function createSafetyOversizedAttributeRule(options) {
                 failFinding(
                   "safety.oversizedAttribute",
                   `Value at ${entry.path} exceeds ${options.maxSerializedBytes} serialized bytes.`,
-                  [eventEvidence2(event, entry.path)],
+                  [eventEvidence3(event, entry.path)],
                   { maxSerializedBytes: options.maxSerializedBytes },
                   { path: entry.path, bytes },
                   {
@@ -4714,7 +5099,7 @@ function createBaselineRegressionRule(options) {
           path: "guardrail",
           expected: guardrailShape(baselineContext),
           actual: guardrailShape(context),
-          evidence: guardrailEvents(context)[0] ? [eventEvidence2(guardrailEvents(context)[0], "guardrail")] : runEvidence(context.selectedRun)
+          evidence: guardrailEvents(context)[0] ? [eventEvidence3(guardrailEvents(context)[0], "guardrail")] : runEvidence(context.selectedRun)
         }
       ];
       for (const comparison of comparisons) {