agent-inspect 6.29.5 → 6.30.0

package/packages/cli/dist/{chunk-XWQEHKGB.mjs → chunk-BDRJENLM.mjs}

@@ -3270,7 +3270,7 @@ function deriveLastError(runs) {
 }
 function deriveCheckSummary(runs) {
   let pass = 0;
-  let fail = 0;
+  let fail4 = 0;
   let warn2 = 0;
   let found = false;
   for (const run of runs) {
@@ -3282,7 +3282,7 @@ function deriveCheckSummary(runs) {
       found = true;
     }
     if (typeof record.fail === "number") {
-      fail += record.fail;
+      fail4 += record.fail;
       found = true;
     }
     if (typeof record.warn === "number") {
@@ -3290,7 +3290,7 @@ function deriveCheckSummary(runs) {
       found = true;
     }
   }
-  return found ? { pass, fail, warn: warn2 } : void 0;
+  return found ? { pass, fail: fail4, warn: warn2 } : void 0;
 }
 function deriveObservationSummary(runs) {
   for (const run of [...runs].sort((a, b) => activityMs(b) - activityMs(a))) {
@@ -5004,7 +5004,1359 @@ function isCredentialSensitiveKey(key, sensitiveKeys = DEFAULT_CREDENTIAL_SENSIT
   return false;
 }
 
+// packages/core/src/checks/contract-scope.ts
+function diagnostic(code, message, ruleId) {
+  return {
+    code,
+    message,
+    severity: "error",
+    ...ruleId !== void 0 ? { ruleId } : {}
+  };
+}
+function isNonEmptyString4(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function scopeEntries(scope) {
+  const out = [];
+  if (isNonEmptyString4(scope.runId)) out.push(["runId", scope.runId.trim()]);
+  if (isNonEmptyString4(scope.subAgentId)) out.push(["subAgentId", scope.subAgentId.trim()]);
+  if (isNonEmptyString4(scope.groupId)) out.push(["groupId", scope.groupId.trim()]);
+  if (isNonEmptyString4(scope.workflowStep)) {
+    out.push(["workflowStep", scope.workflowStep.trim()]);
+  }
+  if (isNonEmptyString4(scope.rootEventId)) {
+    out.push(["rootEventId", scope.rootEventId.trim()]);
+  }
+  return out;
+}
+function mergeWorkflowMeta(into, from) {
+  if (!from) return;
+  for (const [key, value] of Object.entries(from)) {
+    if (value === void 0) continue;
+    if (into[key] === void 0) {
+      into[key] = value;
+    }
+  }
+}
+function workflowMetadataForRun(events, runId) {
+  const preferred = {};
+  const fallback = {};
+  for (const event of events) {
+    if (event.runId !== runId) continue;
+    const attrs = event.attributes;
+    if (!attrs || typeof attrs !== "object") continue;
+    const direct = extractSessionWorkflowMetadata(attrs);
+    const nested = attrs.metadata && typeof attrs.metadata === "object" ? extractSessionWorkflowMetadata(attrs.metadata) : void 0;
+    const bag = {};
+    mergeWorkflowMeta(bag, direct);
+    mergeWorkflowMeta(bag, nested);
+    if (event.kind === "RUN") {
+      mergeWorkflowMeta(preferred, bag);
+    } else {
+      mergeWorkflowMeta(fallback, bag);
+    }
+  }
+  mergeWorkflowMeta(preferred, fallback);
+  return preferred;
+}
+function flattenNodes(nodes) {
+  return nodes.flatMap((node) => [node, ...flattenNodes(node.children)]);
+}
+function collectSubtreeEventIds(run, rootEventId) {
+  const nodes = flattenNodes(run.children);
+  const byId = new Map(nodes.map((node) => [node.event.eventId, node]));
+  const root = byId.get(rootEventId);
+  if (!root) return void 0;
+  const ids = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    ids.add(node.event.eventId);
+    for (const child of node.children) visit(child);
+  };
+  visit(root);
+  return ids;
+}
+function filterTree(nodes, keep) {
+  const out = [];
+  for (const node of nodes) {
+    if (!keep.has(node.event.eventId)) continue;
+    out.push({
+      ...node,
+      children: filterTree(node.children, keep)
+    });
+  }
+  return out;
+}
+function projectInput(input, run, eventIds) {
+  const runEvents = input.read.events.filter((event) => event.runId === run.runId);
+  const projectedEvents = eventIds === void 0 ? runEvents : runEvents.filter((event) => eventIds.has(event.eventId) || event.kind === "RUN");
+  const projectedChildren = eventIds === void 0 ? run.children : filterTree(run.children, eventIds);
+  const projectedRun = {
+    ...run,
+    children: projectedChildren,
+    metadata: {
+      ...run.metadata,
+      totalEvents: flattenNodes(projectedChildren).length
+    }
+  };
+  return {
+    evidenceEventCount: projectedEvents.length,
+    input: {
+      ...input,
+      selectedRun: projectedRun,
+      read: {
+        ...input.read,
+        runs: [projectedRun],
+        events: projectedEvents
+      }
+    }
+  };
+}
+function resolveTraceContractScope(input, scope) {
+  if (scope === void 0) {
+    return { diagnostics: [] };
+  }
+  const entries = scopeEntries(scope);
+  if (entries.length === 0) {
+    return {
+      diagnostics: [
+        diagnostic(
+          "AI_CHECK_INVALID_CONFIG",
+          "TraceContract scope requires at least one explicit selector (runId, subAgentId, groupId, workflowStep, or rootEventId).",
+          "contract.scope.empty"
+        )
+      ]
+    };
+  }
+  const matchedSelectors = Object.fromEntries(entries);
+  const actorKeys = entries.filter(([key]) => key !== "rootEventId");
+  const rootEventId = matchedSelectors.rootEventId;
+  let candidates = [...input.read.runs];
+  if (matchedSelectors.runId) {
+    candidates = candidates.filter((run2) => run2.runId === matchedSelectors.runId);
+  }
+  for (const [key, value] of actorKeys) {
+    if (key === "runId") continue;
+    candidates = candidates.filter((run2) => {
+      const meta = workflowMetadataForRun(input.read.events, run2.runId);
+      const actual = meta[key];
+      return actual === value;
+    });
+  }
+  if (rootEventId && actorKeys.length === 0) {
+    candidates = candidates.filter(
+      (run2) => flattenNodes(run2.children).some((node) => node.event.eventId === rootEventId)
+    );
+  }
+  if (candidates.length === 0) {
+    return {
+      diagnostics: [
+        diagnostic(
+          "AI_CHECK_RUN_SELECTION_REQUIRED",
+          `TraceContract scope matched zero actors for ${JSON.stringify(matchedSelectors)}. Missing actor metadata does not fall back to the whole session.`,
+          "contract.scope.zero-match"
+        )
+      ]
+    };
+  }
+  if (candidates.length > 1) {
+    return {
+      diagnostics: [
+        diagnostic(
+          "AI_CHECK_RUN_SELECTION_REQUIRED",
+          `TraceContract scope matched ${candidates.length} actors for ${JSON.stringify(matchedSelectors)} (runIds: ${candidates.map((run2) => run2.runId).sort().join(", ")}). Singular actor selectors must resolve to exactly one run.`,
+          "contract.scope.ambiguous"
+        )
+      ]
+    };
+  }
+  const run = candidates[0];
+  let eventIds;
+  if (rootEventId) {
+    eventIds = collectSubtreeEventIds(run, rootEventId);
+    if (eventIds === void 0) {
+      return {
+        diagnostics: [
+          diagnostic(
+            "AI_CHECK_INVALID_ARGUMENTS",
+            `TraceContract scope rootEventId ${rootEventId} was not found in run ${run.runId}.`,
+            "contract.scope.root-missing"
+          )
+        ]
+      };
+    }
+  }
+  const projected = projectInput(input, run, eventIds);
+  return {
+    resolved: {
+      runId: run.runId,
+      ...rootEventId !== void 0 ? { rootEventId } : {},
+      matchedSelectors,
+      evidenceEventCount: projected.evidenceEventCount,
+      input: projected.input
+    },
+    diagnostics: []
+  };
+}
+
+// packages/core/src/checks/control-rules.ts
+function asStringList(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "string" || item.trim() === "") return void 0;
+    out.push(item.trim());
+  }
+  return out;
+}
+function attributeList(events, attribute) {
+  if (!attribute) return void 0;
+  for (const event of events) {
+    const attrs = event.attributes;
+    if (!attrs || typeof attrs !== "object") continue;
+    const direct = asStringList(attrs[attribute]);
+    if (direct) return direct;
+    const nested = attrs.metadata && typeof attrs.metadata === "object" ? asStringList(attrs.metadata[attribute]) : void 0;
+    if (nested) return nested;
+  }
+  return void 0;
+}
+function fail(ruleId, message, evidence, expected, actual) {
+  return {
+    ruleId,
+    severity: "error",
+    status: "fail",
+    message,
+    ...expected !== void 0 ? { expected } : {},
+    ...actual !== void 0 ? { actual } : {},
+    evidence: [...evidence]
+  };
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+function setEqual(left, right) {
+  const a = sortedUnique(left);
+  const b = sortedUnique(right);
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function evaluateControlRules(events, rules, runEvidence2, observationNames) {
+  const findings = [];
+  const declared = rules.declaredTools ?? attributeList(events, rules.declaredToolsAttribute);
+  const enforced = rules.enforcedTools ?? attributeList(events, rules.enforcedToolsAttribute);
+  if (rules.requireDeclaredMatchesEnforced) {
+    if (declared === void 0 || enforced === void 0) {
+      findings.push(
+        fail(
+          "contract.controls.declared-matches-enforced",
+          "Declared and enforced tool sets could not both be resolved.",
+          runEvidence2,
+          { declaredDefined: declared !== void 0, enforcedDefined: enforced !== void 0 },
+          { code: "AI_CHECK_CONTROL_EVIDENCE_UNAVAILABLE" }
+        )
+      );
+    } else if (!setEqual(declared, enforced)) {
+      findings.push(
+        fail(
+          "contract.controls.declared-matches-enforced",
+          "Declared tools differ from enforced tools.",
+          runEvidence2,
+          sortedUnique(declared),
+          sortedUnique(enforced)
+        )
+      );
+    }
+  }
+  const observedTools = sortedUnique(
+    events.filter((event) => event.kind === "TOOL" && event.status !== "running").map((event) => resolveCanonicalToolName(event))
+  );
+  if (rules.requireObservedWithinEnforced) {
+    if (enforced === void 0) {
+      findings.push(
+        fail(
+          "contract.controls.observed-within-enforced",
+          "Enforced tool set unavailable for observed-within-enforced check.",
+          runEvidence2,
+          void 0,
+          { code: "AI_CHECK_CONTROL_EVIDENCE_UNAVAILABLE" }
+        )
+      );
+    } else {
+      const enforcedSet = new Set(enforced);
+      const outside = observedTools.filter((name) => !enforcedSet.has(name));
+      if (outside.length > 0) {
+        findings.push(
+          fail(
+            "contract.controls.observed-within-enforced",
+            `Observed tools outside enforced allowlist: ${outside.join(", ")}.`,
+            runEvidence2,
+            sortedUnique(enforced),
+            outside
+          )
+        );
+      }
+    }
+  }
+  if (rules.requireObservedWithinDeclared) {
+    if (declared === void 0) {
+      findings.push(
+        fail(
+          "contract.controls.observed-within-declared",
+          "Declared tool set unavailable for observed-within-declared check.",
+          runEvidence2,
+          void 0,
+          { code: "AI_CHECK_CONTROL_EVIDENCE_UNAVAILABLE" }
+        )
+      );
+    } else {
+      const declaredSet = new Set(declared);
+      const outside = observedTools.filter((name) => !declaredSet.has(name));
+      if (outside.length > 0) {
+        findings.push(
+          fail(
+            "contract.controls.observed-within-declared",
+            `Observed tools outside declared set: ${outside.join(", ")}.`,
+            runEvidence2,
+            sortedUnique(declared),
+            outside
+          )
+        );
+      }
+    }
+  }
+  for (const stage of rules.requiredStages ?? []) {
+    const observation = stage.observation ?? `control.${stage.stage}`;
+    if (!observationNames.has(observation)) {
+      findings.push(
+        fail(
+          `contract.controls.stage.${stage.stage}`,
+          `Required control stage observation missing: ${observation}.`,
+          runEvidence2,
+          observation,
+          [...observationNames]
+        )
+      );
+    }
+  }
+  return findings;
+}
+
+// packages/core/src/checks/canonical-equality.ts
+var DEFAULT_MAX_DEPTH = 8;
+var DEFAULT_MAX_BYTES = 16384;
+function sortKeysDeep(input, depth, maxDepth) {
+  if (depth > maxDepth) {
+    throw new Error("AI_CHECK_CANONICAL_DEPTH_EXCEEDED");
+  }
+  if (input === null || typeof input !== "object") return input;
+  if (Array.isArray(input)) {
+    return input.map((item) => sortKeysDeep(item, depth + 1, maxDepth));
+  }
+  const record = input;
+  const out = {};
+  for (const key of Object.keys(record).sort()) {
+    out[key] = sortKeysDeep(record[key], depth + 1, maxDepth);
+  }
+  return out;
+}
+function encodeCanonicalStructured(value, limits) {
+  const maxDepth = DEFAULT_MAX_DEPTH;
+  const maxBytes = DEFAULT_MAX_BYTES;
+  try {
+    const sorted = sortKeysDeep(value, 0, maxDepth);
+    const encoded = JSON.stringify(sorted);
+    if (encoded === void 0) {
+      return {
+        ok: false,
+        reason: "Value is not JSON-serializable for canonical comparison.",
+        code: "AI_CHECK_CANONICAL_UNSERIALIZABLE"
+      };
+    }
+    if (Buffer.byteLength(encoded, "utf8") > maxBytes) {
+      return {
+        ok: false,
+        reason: "Canonical structured value exceeds bounded size limit.",
+        code: "AI_CHECK_CANONICAL_SIZE_EXCEEDED"
+      };
+    }
+    return { ok: true, value: encoded };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message === "AI_CHECK_CANONICAL_DEPTH_EXCEEDED") {
+      return {
+        ok: false,
+        reason: "Canonical structured value exceeds bounded depth limit.",
+        code: "AI_CHECK_CANONICAL_DEPTH_EXCEEDED"
+      };
+    }
+    return {
+      ok: false,
+      reason: "Canonical structured encoding failed.",
+      code: "AI_CHECK_CANONICAL_UNSERIALIZABLE"
+    };
+  }
+}
+function canonicalStructuredEqual(left, right, limits) {
+  const a = encodeCanonicalStructured(left);
+  if (!a.ok) return { equal: false, reason: a.reason, code: a.code };
+  const b = encodeCanonicalStructured(right);
+  if (!b.ok) return { equal: false, reason: b.reason, code: b.code };
+  if (a.value !== b.value) {
+    return {
+      equal: false,
+      reason: "Canonical structured values differ.",
+      code: "AI_CHECK_CANONICAL_NOT_EQUAL"
+    };
+  }
+  return { equal: true };
+}
+
+// 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 canonicalStructuredEqual(left, right).equal === true;
+}
+function isStructuredArgumentEvidence(value) {
+  return value !== void 0 && value !== null && typeof value === "object";
+}
+function extractToolArgumentPayload(event) {
+  const attrs = event.attributes ?? {};
+  for (const key of ["arguments", "input", "toolArguments"]) {
+    const candidate = attrs[key];
+    if (isStructuredArgumentEvidence(candidate)) {
+      return { present: true, value: candidate };
+    }
+  }
+  const metadata = attrs.metadata;
+  if (isStructuredArgumentEvidence(metadata) && !Array.isArray(metadata)) {
+    const nested = metadata;
+    for (const key of ["arguments", "input", "toolArguments"]) {
+      const candidate = nested[key];
+      if (isStructuredArgumentEvidence(candidate)) {
+        return { present: true, value: candidate };
+      }
+    }
+  }
+  if (isStructuredArgumentEvidence(event.inputSummary)) {
+    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 {
+    ruleId,
+    severity: "error",
+    status: "fail",
+    message,
+    ...expected !== void 0 ? { expected } : {},
+    ...actual !== void 0 ? { actual } : {},
+    evidence: [...evidence]
+  };
+}
+function workflowFor(event) {
+  const attrs = event.attributes;
+  if (!attrs || typeof attrs !== "object") return {};
+  const direct = extractSessionWorkflowMetadata(attrs);
+  const nested = attrs.metadata && typeof attrs.metadata === "object" ? extractSessionWorkflowMetadata(attrs.metadata) : void 0;
+  return { ...nested, ...direct };
+}
+function hasIdempotencyEvidence(event) {
+  const workflow = workflowFor(event);
+  if (typeof workflow.idempotencyKey === "string" && workflow.idempotencyKey.trim() !== "") {
+    return true;
+  }
+  const attrs = event.attributes ?? {};
+  if (attrs.noSideEffect === true) return true;
+  if (attrs.sideEffect === false) return true;
+  return false;
+}
+function eventEvidence(event) {
+  return {
+    runId: event.runId,
+    eventId: event.eventId,
+    kind: event.kind,
+    name: event.name,
+    status: event.status
+  };
+}
+function eventTime(event) {
+  return event.startedAt ?? event.timestamp ?? "";
+}
+function sortByTime(events) {
+  return [...events].sort((a, b) => eventTime(a).localeCompare(eventTime(b)));
+}
+function attemptNumberOf(event) {
+  const workflow = workflowFor(event);
+  const value = workflow.attemptNumber ?? workflow.attempt;
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function attemptIdOf(event) {
+  const value = workflowFor(event).attemptId;
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function countOperationAttempts(members) {
+  const attemptIds = new Set(
+    members.map((event) => attemptIdOf(event)).filter((value) => value !== void 0)
+  );
+  if (attemptIds.size > 0) {
+    return attemptIds.size;
+  }
+  const numbers = members.map((event) => attemptNumberOf(event)).filter((value) => value !== void 0).sort((a, b) => a - b);
+  if (numbers.length > 0) {
+    const unique = [...new Set(numbers)];
+    const min = unique[0];
+    const max = unique[unique.length - 1];
+    const contiguous = unique.length === max - min + 1 && unique.every((value, index) => value === min + index);
+    if (contiguous) {
+      return unique.length;
+    }
+    return unique.length;
+  }
+  return members.filter((event) => event.kind === "TOOL" || event.kind === "LLM").length;
+}
+function classifyRetryAttempt(event, priorOrdered, allMembers) {
+  const workflow = workflowFor(event);
+  const attemptNumber = attemptNumberOf(event);
+  const attemptId = attemptIdOf(event);
+  const retryOf = workflow.retryOf;
+  if (typeof retryOf === "string" && retryOf.trim() !== "") {
+    const target = allMembers.find(
+      (candidate) => candidate.eventId === retryOf || attemptIdOf(candidate) === retryOf || workflowFor(candidate).operationId === retryOf
+    );
+    if (!target) {
+      return { kind: "unknown", reason: "retryOf target missing" };
+    }
+    if (eventTime(target) > eventTime(event)) {
+      return { kind: "unknown", reason: "retryOf target does not precede retry" };
+    }
+    return { kind: "retry" };
+  }
+  if (attemptNumber !== void 0) {
+    if (attemptNumber > 1) {
+      return { kind: "retry" };
+    }
+    if (attemptNumber === 1) {
+      return { kind: "first" };
+    }
+  }
+  if (attemptId !== void 0) {
+    const priorDistinct = priorOrdered.some((candidate) => {
+      const priorId = attemptIdOf(candidate);
+      return priorId !== void 0 && priorId !== attemptId;
+    });
+    if (priorDistinct) {
+      return { kind: "retry" };
+    }
+    if (priorOrdered.length === 0) {
+      return { kind: "first" };
+    }
+  }
+  const priorFinished = priorOrdered.filter(
+    (candidate) => candidate.status === "ok" || candidate.status === "error"
+  );
+  if (priorFinished.length > 0) {
+    return { kind: "retry" };
+  }
+  if (priorOrdered.length === 0) {
+    return { kind: "first" };
+  }
+  return { kind: "unknown", reason: "ambiguous attempt identity" };
+}
+function hasDuplicateAttemptIds(members) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const event of members) {
+    const id = attemptIdOf(event);
+    if (!id) continue;
+    if (seen.has(id)) return true;
+    seen.add(id);
+  }
+  return false;
+}
+function evaluateRetrySafetyRules(events, rules, _runEvidence) {
+  const findings = [];
+  const byOperation = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const workflow = workflowFor(event);
+    const operationId = workflow.operationId;
+    if (!operationId) continue;
+    const list = byOperation.get(operationId) ?? [];
+    list.push(event);
+    byOperation.set(operationId, list);
+  }
+  if (rules.maxAttempts !== void 0) {
+    for (const [operationId, members] of byOperation) {
+      if (hasDuplicateAttemptIds(members)) {
+        findings.push(
+          fail2(
+            "contract.retry.duplicate-attempt-id",
+            `Operation ${operationId} has duplicate attemptId values.`,
+            members.slice(0, 4).map(eventEvidence),
+            "unique attemptId",
+            "duplicate"
+          )
+        );
+      }
+      const count = countOperationAttempts(members);
+      if (count > rules.maxAttempts) {
+        findings.push(
+          fail2(
+            "contract.retry.max-attempts",
+            `Operation ${operationId} exceeded maxAttempts ${rules.maxAttempts}.`,
+            members.slice(0, 4).map(eventEvidence),
+            rules.maxAttempts,
+            count
+          )
+        );
+      }
+    }
+  }
+  if (rules.requireTerminalResult) {
+    for (const [operationId, members] of byOperation) {
+      const hasTerminal = members.some((event) => event.status === "ok" || event.status === "error");
+      if (!hasTerminal) {
+        findings.push(
+          fail2(
+            "contract.retry.terminal-result",
+            `Operation ${operationId} has no terminal ok/error result.`,
+            members.slice(0, 4).map(eventEvidence),
+            "ok|error",
+            members.map((event) => event.status)
+          )
+        );
+      }
+    }
+  }
+  if (rules.fallbackOnlyAfterFailure) {
+    for (const event of events) {
+      const workflow = workflowFor(event);
+      const fallbackOf = workflow.fallbackOf;
+      if (!fallbackOf) continue;
+      const prior = byOperation.get(fallbackOf) ?? [];
+      const fallbackStart = eventTime(event);
+      const earlierFailure = prior.some(
+        (candidate) => candidate.status === "error" && eventTime(candidate) !== "" && fallbackStart !== "" && eventTime(candidate) < fallbackStart
+      );
+      if (!earlierFailure) {
+        findings.push(
+          fail2(
+            "contract.retry.fallback-after-failure",
+            `Fallback for ${fallbackOf} appeared without an earlier failure in the related operation.`,
+            [eventEvidence(event)],
+            "earlier error attempt",
+            { fallbackOf }
+          )
+        );
+      }
+    }
+  }
+  const nonIdempotent = new Set(rules.nonIdempotentTools ?? []);
+  if (nonIdempotent.size > 0 || rules.requireIdempotencyEvidenceForRetry) {
+    const toolEvents = events.filter(
+      (event) => event.kind === "TOOL" && event.status !== "running"
+    );
+    const byToolOp = /* @__PURE__ */ new Map();
+    for (const event of toolEvents) {
+      const name = resolveCanonicalToolName(event);
+      const workflow = workflowFor(event);
+      const key = `${workflow.operationId ?? name}::${name}`;
+      const list = byToolOp.get(key) ?? [];
+      list.push(event);
+      byToolOp.set(key, list);
+    }
+    for (const [, members] of byToolOp) {
+      const ordered = sortByTime(members);
+      let sawOk = false;
+      let sawSideEffectOk = false;
+      const prior = [];
+      for (const event of ordered) {
+        const name = resolveCanonicalToolName(event);
+        const classification = classifyRetryAttempt(event, prior, members);
+        if (classification.kind === "unknown" && rules.requireIdempotencyEvidenceForRetry) {
+          findings.push(
+            fail2(
+              "contract.retry.ambiguous-identity",
+              `Ambiguous attempt identity for tool ${name}; strict retry evidence cannot pass.`,
+              [eventEvidence(event)],
+              "explicit attempt identity",
+              classification.reason
+            )
+          );
+        }
+        const isRetry = classification.kind === "retry";
+        if (isRetry && rules.requireIdempotencyEvidenceForRetry && !hasIdempotencyEvidence(event)) {
+          findings.push(
+            fail2(
+              "contract.retry.idempotency-evidence",
+              `Retry of tool ${name} lacks idempotencyKey / noSideEffect evidence.`,
+              [eventEvidence(event)],
+              "idempotencyKey|noSideEffect",
+              { code: "AI_CHECK_RETRY_EVIDENCE_UNAVAILABLE" }
+            )
+          );
+        }
+        if (sawOk && nonIdempotent.has(name) && sawSideEffectOk && !hasIdempotencyEvidence(event)) {
+          findings.push(
+            fail2(
+              "contract.retry.non-idempotent-side-effect",
+              `Retry of non-idempotent tool ${name} after a confirmed ok side effect.`,
+              [eventEvidence(event)],
+              "no retry after side effect",
+              name
+            )
+          );
+        }
+        if (event.status === "ok") {
+          sawOk = true;
+          if (nonIdempotent.has(name) && !hasIdempotencyEvidence(event)) {
+            sawSideEffectOk = true;
+          }
+        }
+        prior.push(event);
+      }
+    }
+  }
+  if (rules.requireRecoveredFailureVisible) {
+    for (const [operationId, members] of byOperation) {
+      const ordered = sortByTime(members);
+      const toolish = ordered.filter(
+        (event) => (event.kind === "TOOL" || event.kind === "LLM") && (event.status === "ok" || event.status === "error")
+      );
+      if (toolish.length < 2) continue;
+      let sawEarlierError = false;
+      let sawLaterOkAfterError = false;
+      for (const event of toolish) {
+        if (event.status === "error") {
+          sawEarlierError = true;
+        } else if (event.status === "ok" && sawEarlierError) {
+          sawLaterOkAfterError = true;
+        }
+      }
+      const hasOk = toolish.some((event) => event.status === "ok");
+      const attemptish = toolish.some((event) => {
+        const meta = workflowFor(event);
+        return meta.attemptId !== void 0 || meta.attemptNumber !== void 0 || meta.attempt !== void 0 || meta.retryOf !== void 0;
+      }) || toolish.length > 1;
+      if (!attemptish || !hasOk) continue;
+      if (!sawLaterOkAfterError) {
+        findings.push(
+          fail2(
+            "contract.retry.recovered-failure-visible",
+            `Operation ${operationId} does not show an earlier error attempt before a later success in the same chain.`,
+            members.slice(0, 4).map(eventEvidence),
+            "earlier error then later ok",
+            {
+              sawEarlierError,
+              statuses: toolish.map((event) => event.status)
+            }
+          )
+        );
+      }
+    }
+  }
+  return findings;
+}
+
+// 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 workflowFor2(event) {
+  const attrs = event.attributes;
+  if (!attrs || typeof attrs !== "object") return {};
+  const direct = extractSessionWorkflowMetadata(attrs);
+  const nested = attrs.metadata && typeof attrs.metadata === "object" ? extractSessionWorkflowMetadata(attrs.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 errorCodeOf(event) {
+  if (typeof event.error?.code === "string" && event.error.code.trim() !== "") {
+    return event.error.code.trim();
+  }
+  const attrs = event.attributes ?? {};
+  for (const key of ["errorCode", "code"]) {
+    const value = attrs[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
+  }
+  const nested = attrs.error;
+  if (nested && typeof nested === "object") {
+    const code = nested.code;
+    if (typeof code === "string" && code.trim() !== "") return code.trim();
+  }
+  return void 0;
+}
+function argumentDigestOf(event) {
+  const attrs = event.attributes ?? {};
+  for (const key of ["argumentsDigest", "inputDigest", "toolArgumentsDigest"]) {
+    const value = attrs[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
+  }
+  const commitment = attrs.omittedPayloadCommitment;
+  if (commitment && typeof commitment === "object") {
+    const digest = commitment.digest;
+    if (typeof digest === "string" && digest.trim() !== "") return digest.trim();
+  }
+  return void 0;
+}
+function argumentFingerprint(event) {
+  const payload = extractToolArgumentPayload(event);
+  if (payload.present) {
+    const encoded = encodeCanonicalStructured(payload.value);
+    if (!encoded.ok) return { kind: "missing" };
+    return { kind: "structured", value: encoded.value };
+  }
+  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 {
+      ok: false,
+      reason: "Structured or digest argument evidence unavailable for same-arguments check.",
+      code: "AI_CHECK_RECOVERY_ARGUMENT_EVIDENCE_UNAVAILABLE"
+    };
+  }
+  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 (a.value !== b.value) {
+    return {
+      ok: false,
+      reason: "Retry arguments do not match prior attempt.",
+      code: "AI_CHECK_RECOVERY_ARGUMENTS_DIFFER"
+    };
+  }
+  return { ok: true };
+}
+function isUnevaluableWriteCompletion(event) {
+  if (event.status === "running" || event.status === "unknown") return true;
+  const attrs = event.attributes ?? {};
+  if (attrs.timeout === true) return true;
+  if (attrs.completionState === "unknown" || attrs.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 attrs = event.attributes ?? {};
+  const candidates = [
+    attrs.referencedEventId,
+    attrs.referencedEventIds,
+    attrs.toolResultEventId,
+    attrs.toolResultEventIds,
+    attrs.inputEventIds,
+    attrs.dependsOnEventIds,
+    attrs.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 refs;
+}
+function llmReferencesTool(llm, toolEvent, requireExplicit) {
+  if (!requireExplicit) {
+    return eventTime2(llm) >= eventTime2(toolEvent);
+  }
+  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 attemptIdOf2(event) {
+  const value = workflowFor2(event).attemptId;
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function hasDuplicateAttemptIds2(members) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const event of members) {
+    const id = attemptIdOf2(event);
+    if (!id) continue;
+    if (seen.has(id)) return true;
+    seen.add(id);
+  }
+  return false;
+}
+function findRetryTarget(members, retryOf) {
+  return members.find(
+    (candidate) => candidate.eventId === retryOf || attemptIdOf2(candidate) === retryOf || workflowFor2(candidate).operationId === retryOf
+  );
+}
+function groupToolAttempts(events, toolName2) {
+  const members = events.filter(
+    (event) => event.kind === "TOOL" && resolveCanonicalToolName(event) === toolName2
+  );
+  const parent = /* @__PURE__ */ new Map();
+  const ensure = (id) => {
+    if (!parent.has(id)) parent.set(id, id);
+    return id;
+  };
+  const find = (id) => {
+    ensure(id);
+    let cur = id;
+    while (parent.get(cur) !== cur) {
+      cur = parent.get(cur);
+    }
+    let walk = id;
+    while (parent.get(walk) !== cur) {
+      const next = parent.get(walk);
+      parent.set(walk, cur);
+      walk = next;
+    }
+    return cur;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent.set(ra, rb);
+  };
+  const nodeId = (event) => {
+    const operationId = workflowFor2(event).operationId;
+    if (typeof operationId === "string" && operationId.trim() !== "") {
+      return `op:${operationId.trim()}`;
+    }
+    return `event:${event.eventId}`;
+  };
+  for (const event of members) {
+    ensure(nodeId(event));
+  }
+  for (const event of members) {
+    const retryOf = workflowFor2(event).retryOf;
+    if (typeof retryOf !== "string" || retryOf.trim() === "") continue;
+    const target = findRetryTarget(members, retryOf.trim());
+    if (target) {
+      union(nodeId(event), nodeId(target));
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const event of members) {
+    const key = find(nodeId(event));
+    const list = groups.get(key) ?? [];
+    list.push(event);
+    groups.set(key, list);
+  }
+  return groups;
+}
+function latestAttempt(ordered) {
+  if (ordered.length === 0) return void 0;
+  return ordered[ordered.length - 1];
+}
+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 (hasDuplicateAttemptIds2(members)) {
+        findings.push(
+          fail3(
+            "contract.retry.operations.duplicate-attempt-id",
+            `Tool ${operation.tool} operation ${operationKey} has duplicate attemptId values.`,
+            members.slice(0, 4).map(eventEvidence2),
+            "unique attemptId",
+            "duplicate"
+          )
+        );
+      }
+      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)) {
+            findings.push(
+              fail3(
+                "contract.retry.operations.write-completion-unevaluable",
+                `Write tool ${operation.tool} has timeout/unknown/running completion that cannot be verified as an authoritative write result.`,
+                [eventEvidence2(event)],
+                "authoritative write completion observation",
+                {
+                  code: "AI_CHECK_RECOVERY_WRITE_COMPLETION_UNAVAILABLE",
+                  status: event.status
+                }
+              )
+            );
+          }
+        }
+      }
+      const prior = [];
+      let sawEarlierError = false;
+      let sawLaterOkAfterError = false;
+      let lastOk;
+      let identityUnavailable = false;
+      for (const event of ordered) {
+        const classification = classifyRetryAttempt(event, prior, members);
+        if (classification.kind === "unknown") {
+          identityUnavailable = true;
+          findings.push(
+            fail3(
+              "contract.retry.operations.attempt-identity",
+              `Tool ${operation.tool} operation ${operationKey} has ambiguous attempt identity (${classification.reason}).`,
+              [eventEvidence2(event)],
+              "explicit operationId/attemptId/retryOf chronology",
+              { code: "AI_CHECK_RECOVERY_ATTEMPT_IDENTITY_UNAVAILABLE", reason: classification.reason }
+            )
+          );
+        }
+        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
+                )
+              );
+            }
+          } else {
+            findings.push(
+              fail3(
+                "contract.retry.operations.retryable-error",
+                `Retry of tool ${operation.tool} has no prior error code evidence.`,
+                [eventEvidence2(event)],
+                [...allowed],
+                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 }
+                )
+              );
+            }
+          } else {
+            findings.push(
+              fail3(
+                "contract.retry.operations.same-arguments",
+                "Structured or digest argument evidence unavailable for same-arguments check.",
+                [eventEvidence2(event)],
+                "matching structured args or digests",
+                { code: "AI_CHECK_RECOVERY_ARGUMENT_EVIDENCE_UNAVAILABLE" }
+              )
+            );
+          }
+        }
+        if (event.status === "error") {
+          sawEarlierError = true;
+        } else if (event.status === "ok" && sawEarlierError) {
+          sawLaterOkAfterError = true;
+        }
+        if (event.status === "ok") {
+          lastOk = event;
+        }
+        prior.push(event);
+      }
+      const latest = latestAttempt(ordered);
+      if (operation.requireTerminalSuccess) {
+        if (!latest || latest.status !== "ok") {
+          findings.push(
+            fail3(
+              "contract.retry.operations.terminal-success",
+              `Tool ${operation.tool} operation ${operationKey} does not terminate with ok on the latest attempt.`,
+              ordered.slice(0, 4).map(eventEvidence2),
+              "latest attempt ok",
+              latest?.status ?? "missing"
+            )
+          );
+        }
+      }
+      if (operation.requireRecoveredFailureVisible) {
+        const latestOk = latest?.status === "ok";
+        if (ordered.length > 1 && latestOk && !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") {
+        const successForDependency = latest?.status === "ok" ? latest : identityUnavailable ? void 0 : lastOk;
+        if (successForDependency) {
+          if (sideEffectClass === "write" && isUnevaluableWriteCompletion(successForDependency)) {
+            findings.push(
+              fail3(
+                "contract.retry.operations.successful-result-dependency",
+                `Successful ${operation.tool} result dependency is unevaluable because write completion evidence is unavailable.`,
+                [eventEvidence2(successForDependency)],
+                "LLM reference to successful tool event",
+                { code: "AI_CHECK_RECOVERY_WRITE_COMPLETION_UNAVAILABLE" }
+              )
+            );
+          } else {
+            const requireExplicit = dependency.requireExplicitReference === true;
+            const referenced = llmEvents.some(
+              (llmEvent) => llmReferencesTool(llmEvent, successForDependency, 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(successForDependency)],
+                  "LLM reference to successful tool event",
+                  { code: "AI_CHECK_RECOVERY_RESULT_DEPENDENCY_MISSING" }
+                )
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  return findings;
+}
+
 // packages/core/src/checks/contract.ts
+function contractFailFinding(ruleId, message, evidence, expected, actual) {
+  return {
+    ruleId,
+    severity: "error",
+    status: "fail",
+    message,
+    ...expected !== void 0 ? { expected } : {},
+    ...actual !== void 0 ? { actual } : {},
+    evidence: [...evidence]
+  };
+}
+function normalizeStatus(status) {
+  if (status === "ok" || status === "error" || status === "running") return status;
+  if (status === "success") return "ok";
+  if (status === "failed") return "error";
+  return "error";
+}
 function cloneBody(body) {
   return {
     ...body.run ? { run: { ...body.run } } : {},
@@ -5029,35 +6381,471 @@ function cloneBody(body) {
         ...body.controls.enforcedTools ? { enforcedTools: [...body.controls.enforcedTools] } : {},
         ...body.controls.requiredStages ? { requiredStages: body.controls.requiredStages.map((item) => ({ ...item })) } : {}
       }
-    } : {},
-    ...body.retry ? {
-      retry: {
-        ...body.retry,
-        ...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
-              }
-            } : {}
-          }))
-        } : {}
+    } : {},
+    ...body.retry ? {
+      retry: {
+        ...body.retry,
+        ...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
+              }
+            } : {}
+          }))
+        } : {}
+      }
+    } : {}
+  };
+}
+function bodyHasRules(body) {
+  return body.run !== void 0 || body.tools !== void 0 || body.llm !== void 0 || body.observations !== void 0 || body.controls !== void 0 || body.retry !== void 0;
+}
+var MAX_EVIDENCE_EVENT_IDS = 16;
+var METHOD_VOCABULARY = new Set(OBSERVED_OUTCOME_METHODS);
+function parseEvidenceEventIds(evidence) {
+  if (evidence === void 0 || evidence === null) {
+    return { status: "missing" };
+  }
+  if (typeof evidence === "string") {
+    const trimmed = evidence.trim();
+    if (trimmed === "") {
+      return { status: "invalid", reason: "empty evidence string" };
+    }
+    return { status: "ok", eventIds: [trimmed] };
+  }
+  if (typeof evidence !== "object" || Array.isArray(evidence)) {
+    return {
+      status: "invalid",
+      reason: "evidence must be a string event id or { eventId } / { eventIds }"
+    };
+  }
+  const record = evidence;
+  if (typeof record.eventId === "string") {
+    const trimmed = record.eventId.trim();
+    if (trimmed === "") {
+      return { status: "invalid", reason: "empty evidence.eventId" };
+    }
+    return { status: "ok", eventIds: [trimmed] };
+  }
+  if (Array.isArray(record.eventIds)) {
+    if (record.eventIds.length === 0) {
+      return { status: "invalid", reason: "empty evidence.eventIds" };
+    }
+    if (record.eventIds.length > MAX_EVIDENCE_EVENT_IDS) {
+      return {
+        status: "invalid",
+        reason: `evidence.eventIds exceeds bound of ${MAX_EVIDENCE_EVENT_IDS}`
+      };
+    }
+    const eventIds = [];
+    for (const item of record.eventIds) {
+      if (typeof item !== "string" || item.trim() === "") {
+        return { status: "invalid", reason: "evidence.eventIds contains a non-string id" };
+      }
+      eventIds.push(item.trim());
+    }
+    return { status: "ok", eventIds };
+  }
+  return {
+    status: "invalid",
+    reason: "evidence must include eventId or eventIds"
+  };
+}
+function provenanceFindingsForOutcome(outcome, requireProvenance, knownEventIds) {
+  const findings = [];
+  const evidenceBase = [
+    {
+      runId: outcome.runId,
+      eventId: outcome.outcomeId,
+      kind: "OUTCOME",
+      name: outcome.name,
+      path: `outcome.${outcome.name}`
+    }
+  ];
+  if (requireProvenance.method) {
+    if (outcome.method === void 0 || outcome.method.trim() === "") {
+      findings.push(
+        contractFailFinding(
+          "contract.observation.provenance.method",
+          `Observation ${outcome.name} is missing a structural method.`,
+          evidenceBase,
+          { method: true },
+          { name: outcome.name, method: outcome.method ?? null }
+        )
+      );
+    } else if (!METHOD_VOCABULARY.has(outcome.method)) {
+      findings.push(
+        contractFailFinding(
+          "contract.observation.provenance.method",
+          `Observation ${outcome.name} method ${outcome.method} is outside the bounded ObservedOutcomeMethod vocabulary.`,
+          evidenceBase,
+          { methodVocabulary: [...OBSERVED_OUTCOME_METHODS] },
+          { name: outcome.name, method: outcome.method }
+        )
+      );
+    }
+  }
+  if (requireProvenance.evidence || requireProvenance.sameRunEventReference) {
+    const parsed = parseEvidenceEventIds(outcome.evidence);
+    if (parsed.status === "missing") {
+      findings.push(
+        contractFailFinding(
+          "contract.observation.provenance.evidence",
+          `Observation ${outcome.name} is missing bounded evidence references.`,
+          evidenceBase,
+          { evidence: true },
+          { name: outcome.name, evidence: null }
+        )
+      );
+    } else if (parsed.status === "invalid") {
+      findings.push(
+        contractFailFinding(
+          "contract.observation.provenance.evidence",
+          `Observation ${outcome.name} evidence is not a bounded event reference (${parsed.reason}).`,
+          evidenceBase,
+          { evidence: true },
+          { name: outcome.name, reason: parsed.reason }
+        )
+      );
+    } else if (requireProvenance.sameRunEventReference) {
+      const missing = parsed.eventIds.filter((eventId) => !knownEventIds.has(eventId));
+      if (missing.length > 0) {
+        findings.push(
+          contractFailFinding(
+            "contract.observation.provenance.same-run",
+            `Observation ${outcome.name} references event ids missing from the same run: ${missing.join(", ")}.`,
+            evidenceBase,
+            { sameRunEventReference: true, eventIds: parsed.eventIds },
+            { name: outcome.name, missing }
+          )
+        );
+      }
+    }
+  }
+  return findings;
+}
+function contractToRules(contract) {
+  const rules = [];
+  const allowedStatuses = contract.run?.allowedStatuses ?? [];
+  if (allowedStatuses.length === 1) {
+    rules.push(
+      createRunStatusRule({
+        expected: normalizeStatus(allowedStatuses[0]),
+        allowIncomplete: contract.run?.requireCompleted === false
+      })
+    );
+  } else if (allowedStatuses.length > 1) {
+    const expected = [...new Set(allowedStatuses.map(normalizeStatus))];
+    const allowIncomplete = contract.run?.requireCompleted === false;
+    rules.push({
+      id: "contract.run.allowedStatuses",
+      category: "run",
+      defaultSeverity: "error",
+      evaluate(context) {
+        const findings = [];
+        const actual = context.selectedRun?.status ?? "unknown";
+        if (!expected.includes(actual)) {
+          findings.push(
+            contractFailFinding(
+              "contract.run.allowedStatuses",
+              `Run status ${actual} is not one of the allowed statuses: ${expected.join(", ")}.`,
+              context.selectedRun ? [
+                {
+                  runId: context.selectedRun.runId,
+                  kind: "RUN",
+                  name: context.selectedRun.name,
+                  status: context.selectedRun.status
+                }
+              ] : [],
+              expected,
+              actual
+            )
+          );
+        }
+        if (!allowIncomplete) {
+          const running = (context.logicalEvents ?? context.events).filter(
+            (event) => event.status === "running"
+          );
+          if (running.length > 0) {
+            findings.push(
+              contractFailFinding(
+                "contract.run.allowedStatuses",
+                "Run contains incomplete running events.",
+                running.map((event) => ({
+                  runId: event.runId,
+                  eventId: event.eventId,
+                  kind: event.kind,
+                  name: event.name,
+                  status: event.status
+                })),
+                "no running events",
+                running.length
+              )
+            );
+          }
+        }
+        return findings;
+      }
+    });
+  } else if (contract.run?.requireCompleted !== false) {
+    rules.push(createRunStatusRule({ allowIncomplete: false }));
+  }
+  if (contract.run?.maxDurationMs !== void 0) {
+    rules.push(createRunDurationRule({ maxDurationMs: contract.run.maxDurationMs }));
+  }
+  if (contract.run?.requireCompleted === true) {
+    rules.push(createStructureIncompleteRule({ requireEndedAtForStarted: true }));
+  }
+  if (contract.tools) {
+    const order = contract.tools.requiredOrder ?? [];
+    const requiredOrderMode = contract.tools.requiredOrderMode ?? "first-occurrence";
+    const orderRules = contract.tools.orderRules ?? [];
+    const endpointRequired = orderRules.filter((rule) => rule.requireEndpoints !== false).flatMap((rule) => [rule.before, rule.after]);
+    const required = [
+      .../* @__PURE__ */ new Set([
+        ...contract.tools.required ?? [],
+        ...contract.tools.requiredTools ?? [],
+        ...order,
+        ...endpointRequired
+      ])
+    ];
+    const forbidden = [
+      ...contract.tools.forbidden ?? [],
+      ...contract.tools.forbiddenTools ?? []
+    ];
+    rules.push(
+      createToolUsageRule({
+        ...required.length > 0 ? { required } : {},
+        ...forbidden.length > 0 ? { forbidden } : {},
+        ...contract.tools.allowed ? { allowed: contract.tools.allowed } : {},
+        ...contract.tools.maxCalls !== void 0 ? { maxCount: contract.tools.maxCalls } : {}
+      })
+    );
+    for (let i = 0; i < order.length - 1; i += 1) {
+      rules.push(
+        createToolOrderingRule({
+          before: order[i],
+          after: order[i + 1],
+          id: `contract.tool.order.${i}`,
+          mode: requiredOrderMode
+        })
+      );
+    }
+    const defaultOccurrenceMode = contract.tools.defaultOccurrenceMode ?? requiredOrderMode;
+    for (const [index, rule] of orderRules.entries()) {
+      rules.push(
+        createToolOrderingRule({
+          before: rule.before,
+          after: rule.after,
+          id: `contract.tool.orderRule.${index}`,
+          mode: rule.occurrenceMode ?? defaultOccurrenceMode
+        })
+      );
+    }
+    const argumentChecks = contract.tools.arguments ?? [];
+    if (argumentChecks.length > 0) {
+      rules.push({
+        id: "contract.tool.arguments",
+        category: "tool",
+        defaultSeverity: "error",
+        evaluate(context) {
+          const tools = (context.logicalEvents ?? context.events).filter(
+            (event) => event.kind === "TOOL" && event.status !== "running"
+          );
+          const findings = [];
+          for (const [index, check] of argumentChecks.entries()) {
+            const matches = tools.filter(
+              (event) => resolveCanonicalToolName(event) === check.tool
+            );
+            if (matches.length === 0) {
+              findings.push(
+                contractFailFinding(
+                  `contract.tool.arguments.${index}`,
+                  `No finished tool named ${check.tool} for argument check.`,
+                  context.selectedRun ? [
+                    {
+                      runId: context.selectedRun.runId,
+                      kind: "RUN",
+                      name: context.selectedRun.name
+                    }
+                  ] : [],
+                  { tool: check.tool, path: check.path },
+                  { toolCount: 0 }
+                )
+              );
+              continue;
+            }
+            const occurrence = check.occurrence ?? "all";
+            const selected = occurrence === "first" ? [matches[0]] : occurrence === "last" ? [matches[matches.length - 1]] : matches;
+            const results = selected.map((event) => {
+              const payload = extractToolArgumentPayload(event);
+              return evaluateToolArgumentValue(
+                payload.value,
+                check,
+                payload.present
+              );
+            });
+            if (occurrence === "any") {
+              if (results.some((result) => result.status === "pass")) continue;
+              const firstFail = results.find((result) => result.status !== "pass");
+              findings.push(
+                contractFailFinding(
+                  `contract.tool.arguments.${index}`,
+                  firstFail.message,
+                  selected.slice(0, 1).map((event) => ({
+                    runId: event.runId,
+                    eventId: event.eventId,
+                    kind: event.kind,
+                    name: event.name,
+                    path: `tool.${check.tool}${check.path}`
+                  })),
+                  { tool: check.tool, path: check.path, operator: check.operator },
+                  { code: firstFail.code }
+                )
+              );
+              continue;
+            }
+            for (const [selIndex, result] of results.entries()) {
+              if (result.status === "pass") continue;
+              const event = selected[selIndex];
+              findings.push(
+                contractFailFinding(
+                  `contract.tool.arguments.${index}`,
+                  result.message,
+                  [
+                    {
+                      runId: event.runId,
+                      eventId: event.eventId,
+                      kind: event.kind,
+                      name: event.name,
+                      path: `tool.${check.tool}${check.path}`
+                    }
+                  ],
+                  { tool: check.tool, path: check.path, operator: check.operator },
+                  { code: result.code }
+                )
+              );
+            }
+          }
+          return findings;
+        }
+      });
+    }
+  }
+  if (contract.llm) {
+    rules.push(
+      createLlmUsageRule({
+        ...contract.llm.maxCalls !== void 0 ? { maxCalls: contract.llm.maxCalls } : {},
+        ...contract.llm.maxTotalTokens !== void 0 ? { maxTotalTokens: contract.llm.maxTotalTokens } : {},
+        ...contract.llm.allowedModels ? { allowedModels: contract.llm.allowedModels } : {}
+      })
+    );
+  }
+  if (contract.observations) {
+    const required = contract.observations.required ?? [];
+    if (required.length > 0) {
+      rules.push({
+        id: "contract.observation.required",
+        category: "run",
+        defaultSeverity: "error",
+        evaluate(context) {
+          const outcomes = extractOutcomesFromPersistedEvents(context.events);
+          const names = new Set(outcomes.map((item) => item.name));
+          const missing = required.filter((name) => !names.has(name));
+          if (missing.length === 0) return [];
+          return [
+            contractFailFinding(
+              "contract.observation.required",
+              `Required observations missing: ${missing.join(", ")}`,
+              context.selectedRun ? [{ runId: context.selectedRun.runId, kind: "RUN", name: context.selectedRun.name }] : [],
+              required,
+              [...names]
+            )
+          ];
+        }
+      });
+    }
+    if (contract.observations.failOn?.length) {
+      rules.push(
+        createObservedOutcomeRule({
+          failOn: contract.observations.failOn.filter(
+            (status) => status === "failed" || status === "unknown" || status === "skipped"
+          )
+        })
+      );
+    }
+    const requireProvenance = contract.observations.requireProvenance;
+    if (requireProvenance && (requireProvenance.method || requireProvenance.evidence || requireProvenance.sameRunEventReference)) {
+      rules.push({
+        id: "contract.observation.provenance",
+        category: "run",
+        defaultSeverity: "error",
+        evaluate(context) {
+          const outcomes = extractOutcomesFromPersistedEvents(context.events);
+          const knownEventIds = new Set(context.events.map((event) => event.eventId));
+          const targets = required.length > 0 ? outcomes.filter((outcome) => required.includes(outcome.name)) : outcomes;
+          return targets.flatMap(
+            (outcome) => provenanceFindingsForOutcome(outcome, requireProvenance, knownEventIds)
+          );
+        }
+      });
+    }
+  }
+  if (contract.controls) {
+    const controls = contract.controls;
+    rules.push({
+      id: "contract.controls",
+      category: "run",
+      defaultSeverity: "error",
+      evaluate(context) {
+        const events = context.logicalEvents ?? context.events;
+        const outcomes = extractOutcomesFromPersistedEvents(context.events);
+        const observationNames = new Set(outcomes.map((item) => item.name));
+        const runEvidence2 = context.selectedRun ? [
+          {
+            runId: context.selectedRun.runId,
+            kind: "RUN",
+            name: context.selectedRun.name
+          }
+        ] : [];
+        return evaluateControlRules(events, controls, runEvidence2, observationNames);
+      }
+    });
+  }
+  if (contract.retry) {
+    const retry = contract.retry;
+    rules.push({
+      id: "contract.retry",
+      category: "run",
+      defaultSeverity: "error",
+      evaluate(context) {
+        const events = context.logicalEvents ?? context.events;
+        context.selectedRun ? [
+          {
+            runId: context.selectedRun.runId,
+            kind: "RUN",
+            name: context.selectedRun.name
+          }
+        ] : [];
+        const base = evaluateRetrySafetyRules(events, retry);
+        if (!retry.operations || retry.operations.length === 0) {
+          return base;
+        }
+        return [...base, ...evaluateRecoveryOperations(events, retry.operations)];
       }
-    } : {}
-  };
-}
-function bodyHasRules(body) {
-  return body.run !== void 0 || body.tools !== void 0 || body.llm !== void 0 || body.observations !== void 0 || body.controls !== void 0 || body.retry !== void 0;
+    });
+  }
+  return rules;
 }
-new Set(OBSERVED_OUTCOME_METHODS);
 function validateScopeShape(scope) {
   if (scope === void 0) return [];
   const hasSelector = typeof scope.runId === "string" && scope.runId.trim() !== "" || typeof scope.subAgentId === "string" && scope.subAgentId.trim() !== "" || typeof scope.groupId === "string" && scope.groupId.trim() !== "" || typeof scope.workflowStep === "string" && scope.workflowStep.trim() !== "" || typeof scope.rootEventId === "string" && scope.rootEventId.trim() !== "";
@@ -5158,6 +6946,57 @@ function validateAlternativesShape(alternatives) {
   }
   return diagnostics;
 }
+function emptyPassResult(input, runId) {
+  return {
+    ok: true,
+    status: "pass",
+    format: input.read.format,
+    ...runId !== void 0 ? { runId } : {},
+    summary: { passed: 0, failed: 0, warnings: 0, errors: 0, rulesEvaluated: 0 },
+    findings: [],
+    diagnostics: [],
+    ruleExecutions: []
+  };
+}
+function mergeContractResults(input, parts, extraFindings = []) {
+  const findings = [...parts.flatMap((part) => part.findings), ...extraFindings];
+  const diagnostics = parts.flatMap((part) => part.diagnostics);
+  const ruleExecutions = parts.flatMap((part) => part.ruleExecutions);
+  const failed = findings.filter(
+    (finding) => finding.status === "fail" && finding.severity === "error"
+  ).length;
+  const errors = diagnostics.filter((item) => item.severity === "error").length;
+  const status = errors > 0 ? "error" : failed > 0 ? "fail" : "pass";
+  const runId = parts.find((part) => part.runId !== void 0)?.runId;
+  return {
+    ok: status === "pass",
+    status,
+    format: input.read.format,
+    ...runId !== void 0 ? { runId } : {},
+    summary: {
+      passed: findings.filter((finding) => finding.status === "pass").length,
+      failed,
+      warnings: findings.filter(
+        (finding) => finding.status === "warning" || finding.severity === "warning"
+      ).length,
+      errors,
+      rulesEvaluated: ruleExecutions.length
+    },
+    findings,
+    diagnostics,
+    ruleExecutions
+  };
+}
+function evaluateBody(input, body, options = {}) {
+  const rules = contractToRules(body);
+  if (rules.length === 0) {
+    return emptyPassResult(input, options.runId);
+  }
+  return runTraceChecks(input, {
+    rules,
+    ...options.runId !== void 0 ? { runId: options.runId } : {}
+  });
+}
 function defineTraceContract(input) {
   const shapeErrors = [
     ...validateAlternativesShape(input.alternatives),
@@ -5188,6 +7027,143 @@ function defineTraceContract(input) {
     ...alternatives ? { alternatives } : {}
   };
 }
+function evaluateTraceContract(input, contract, options = {}) {
+  const shapeErrors = [
+    ...validateAlternativesShape(contract.alternatives),
+    ...validateScopeShape(contract.scope),
+    ...validateProvenanceShape(contract.observations)
+  ].filter((item) => item.severity === "error");
+  if (shapeErrors.length > 0) {
+    return {
+      ok: false,
+      status: "error",
+      format: input.read.format,
+      ...options.runId !== void 0 ? { runId: options.runId } : {},
+      summary: {
+        passed: 0,
+        failed: 0,
+        warnings: 0,
+        errors: shapeErrors.length,
+        rulesEvaluated: 0
+      },
+      findings: [],
+      diagnostics: shapeErrors.map((item) => ({
+        code: "AI_CHECK_INVALID_CONFIG",
+        message: item.message,
+        severity: "error",
+        ruleId: item.code
+      })),
+      ruleExecutions: []
+    };
+  }
+  const scoped = resolveTraceContractScope(input, contract.scope);
+  if (scoped.diagnostics.length > 0) {
+    return {
+      ok: false,
+      status: "error",
+      format: input.read.format,
+      ...options.runId !== void 0 ? { runId: options.runId } : {},
+      ...scoped.resolved?.runId !== void 0 ? { runId: scoped.resolved.runId } : {},
+      summary: {
+        passed: 0,
+        failed: 0,
+        warnings: 0,
+        errors: scoped.diagnostics.length,
+        rulesEvaluated: 0
+      },
+      findings: [],
+      diagnostics: scoped.diagnostics,
+      ruleExecutions: []
+    };
+  }
+  const effectiveInput = scoped.resolved?.input ?? input;
+  const effectiveRunId = scoped.resolved?.runId ?? options.runId;
+  const base = evaluateBody(effectiveInput, contract, {
+    ...effectiveRunId !== void 0 ? { runId: effectiveRunId } : {}
+  });
+  const scopeFinding = scoped.resolved ? {
+    ruleId: "contract.scope.selected",
+    severity: "info",
+    status: "pass",
+    message: `Selected actor ${scoped.resolved.runId} with ${scoped.resolved.evidenceEventCount} evidence event(s).`,
+    expected: scoped.resolved.matchedSelectors,
+    actual: {
+      runId: scoped.resolved.runId,
+      evidenceEventCount: scoped.resolved.evidenceEventCount,
+      ...scoped.resolved.rootEventId !== void 0 ? { rootEventId: scoped.resolved.rootEventId } : {}
+    },
+    evidence: [
+      {
+        runId: scoped.resolved.runId,
+        kind: "RUN",
+        path: "scope"
+      }
+    ]
+  } : void 0;
+  const branches = contract.alternatives?.anyOf ?? [];
+  if (branches.length === 0) {
+    return scopeFinding ? mergeContractResults(effectiveInput, [base], [scopeFinding]) : base;
+  }
+  const branchEvaluations = branches.map((branch) => {
+    const result = evaluateBody(effectiveInput, branch.contract, {
+      ...effectiveRunId !== void 0 ? { runId: effectiveRunId } : {}
+    });
+    return { branch, result };
+  });
+  const satisfied = branchEvaluations.filter((item) => item.result.ok && item.result.status === "pass").map((item) => item.branch.id);
+  const failedBranches = branchEvaluations.filter(
+    (item) => !(item.result.ok && item.result.status === "pass")
+  );
+  if (satisfied.length > 0) {
+    const passFinding = {
+      ruleId: "contract.alternatives.anyOf",
+      severity: "info",
+      status: "pass",
+      message: `Satisfied alternative branch(es): ${satisfied.join(", ")}.`,
+      expected: { anyOf: branches.map((branch) => branch.id) },
+      actual: {
+        satisfied,
+        failed: failedBranches.map((item) => item.branch.id)
+      },
+      evidence: []
+    };
+    return mergeContractResults(
+      effectiveInput,
+      [base],
+      [...scopeFinding ? [scopeFinding] : [], passFinding]
+    );
+  }
+  const noneFinding = {
+    ruleId: "contract.alternatives.none-satisfied",
+    severity: "error",
+    status: "fail",
+    message: "No alternatives.anyOf branch fully satisfied its contract.",
+    expected: { anyOf: branches.map((branch) => branch.id) },
+    actual: {
+      branchFailures: Object.fromEntries(
+        failedBranches.map((item) => [
+          item.branch.id,
+          item.result.findings.filter((finding) => finding.status === "fail").map((finding) => ({
+            ruleId: finding.ruleId,
+            message: finding.message
+          }))
+        ])
+      )
+    },
+    evidence: []
+  };
+  const prefixedBranchFindings = failedBranches.flatMap(
+    (item) => item.result.findings.filter((finding) => finding.status === "fail").map((finding) => ({
+      ...finding,
+      ruleId: `contract.alternatives.${item.branch.id}.${finding.ruleId}`
+    }))
+  );
+  return mergeContractResults(
+    effectiveInput,
+    [base],
+    [...scopeFinding ? [scopeFinding] : [], noneFinding, ...prefixedBranchFindings]
+  );
+}
 
 // packages/core/src/checks/index.ts
 var SEVERITY_RANK = {
@@ -5277,7 +7253,7 @@ var DEFAULT_SECRET_PATTERNS = [
 function compareStrings(a, b) {
   return (a ?? "").localeCompare(b ?? "");
 }
-function diagnostic(code, message, ruleId) {
+function diagnostic2(code, message, ruleId) {
   return {
     code,
     message,
@@ -5310,14 +7286,14 @@ function errorResult(input, diagnostics, selectedRun, ruleExecutions = []) {
     ruleExecutions: [...ruleExecutions]
   };
 }
-function flattenNodes(nodes) {
-  return nodes.flatMap((node) => [node, ...flattenNodes(node.children)]);
+function flattenNodes2(nodes) {
+  return nodes.flatMap((node) => [node, ...flattenNodes2(node.children)]);
 }
 function buildFacts2(input, selectedRun) {
   const scopedRuns = selectedRun ? [selectedRun] : input.read.runs;
   const scopedRunIds = new Set(scopedRuns.map((run) => run.runId));
   const scopedEvents = selectedRun === void 0 ? input.read.events : input.read.events.filter((event) => scopedRunIds.has(event.runId));
-  const nodes = flattenNodes(scopedRuns.flatMap((run) => run.children));
+  const nodes = flattenNodes2(scopedRuns.flatMap((run) => run.children));
   const nodesByEventId = /* @__PURE__ */ new Map();
   const childrenByParentId = /* @__PURE__ */ new Map();
   for (const node of nodes) {
@@ -5349,7 +7325,7 @@ function resolveSelectedRun(input, runId) {
     if (runId && input.selectedRun.runId !== runId) {
       return {
         diagnostics: [
-          diagnostic(
+          diagnostic2(
             "AI_CHECK_INVALID_ARGUMENTS",
             `Selected run ${input.selectedRun.runId} does not match requested run ${runId}.`
           )
@@ -5363,7 +7339,7 @@ function resolveSelectedRun(input, runId) {
     if (!run) {
       return {
         diagnostics: [
-          diagnostic("AI_CHECK_RUN_SELECTION_REQUIRED", `Run not found: ${runId}.`)
+          diagnostic2("AI_CHECK_RUN_SELECTION_REQUIRED", `Run not found: ${runId}.`)
         ]
       };
     }
@@ -5375,7 +7351,7 @@ function resolveSelectedRun(input, runId) {
   if (input.read.runs.length === 0) {
     return {
       diagnostics: [
-        diagnostic(
+        diagnostic2(
           "AI_CHECK_RUN_SELECTION_REQUIRED",
           formatProgrammaticDiagnostic(
             "AI_TRACE_CONTRACT_RUN_SELECTION_REQUIRED",
@@ -5387,7 +7363,7 @@ function resolveSelectedRun(input, runId) {
   }
   return {
     diagnostics: [
-      diagnostic(
+      diagnostic2(
         "AI_CHECK_RUN_SELECTION_REQUIRED",
         formatProgrammaticDiagnostic("AI_TRACE_CONTRACT_RUN_SELECTION_REQUIRED")
       )
@@ -5400,7 +7376,7 @@ function selectRules(rules, selectedIds) {
   for (const rule of rules) {
     if (byId.has(rule.id)) {
       diagnostics.push(
-        diagnostic("AI_CHECK_INVALID_CONFIG", `Duplicate trace check rule id: ${rule.id}.`, rule.id)
+        diagnostic2("AI_CHECK_INVALID_CONFIG", `Duplicate trace check rule id: ${rule.id}.`, rule.id)
       );
       continue;
     }
@@ -5411,7 +7387,7 @@ function selectRules(rules, selectedIds) {
     for (const id of selected) {
       if (!byId.has(id)) {
         diagnostics.push(
-          diagnostic("AI_CHECK_INVALID_CONFIG", `Unknown trace check rule id: ${id}.`, id)
+          diagnostic2("AI_CHECK_INVALID_CONFIG", `Unknown trace check rule id: ${id}.`, id)
         );
       }
     }
@@ -5526,7 +7502,7 @@ function stripPrefix(name, prefixes) {
   }
   return name;
 }
-function eventEvidence(event, path14) {
+function eventEvidence3(event, path14) {
   return {
     runId: event.runId,
     eventId: event.eventId,
@@ -5586,6 +7562,14 @@ function finishedEvents(context, kind) {
 function toolInvocationEvents(context) {
   return semanticEvents(context).filter((event) => event.kind === "TOOL");
 }
+function firstIndexByName(events) {
+  const index = /* @__PURE__ */ new Map();
+  for (const [position, event] of events.entries()) {
+    const name = toolName(event);
+    if (!index.has(name)) index.set(name, position);
+  }
+  return index;
+}
 function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -5674,6 +7658,18 @@ function limitFindings(findings, maxFindings) {
 function hasRedactionMarker(value, markers) {
   return markers.some((marker) => value.includes(marker)) || /^\[HASH:[A-Za-z0-9_-]+\]$/.test(value);
 }
+function isFullyRedactedValue(value, markers = ["[REDACTED]", "[REDACTED:"]) {
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return false;
+  if (/^\[HASH:[A-Za-z0-9_-]+\]$/.test(trimmed)) return true;
+  if (/^\[REDACTED:[^\]]*\]$/.test(trimmed)) return true;
+  for (const marker of markers) {
+    if (marker.endsWith(":")) continue;
+    if (trimmed === marker) return true;
+  }
+  return false;
+}
 function isSensitiveKey(key, sensitiveKeys) {
   return isCredentialSensitiveKey(key, sensitiveKeys);
 }
@@ -5785,7 +7781,7 @@ function guardrailShape(context) {
 }
 function firstEvidenceForKind(context, kind, path14) {
   const event = semanticEvents(context).find((candidate) => candidate.kind === kind);
-  return event ? [eventEvidence(event, path14)] : runEvidence(context.selectedRun);
+  return event ? [eventEvidence3(event, path14)] : runEvidence(context.selectedRun);
 }
 function baselineDiffFinding(message, evidence, expected, actual) {
   return failFinding("baseline.regression", message, evidence, expected, actual);
@@ -5818,7 +7814,7 @@ function createRunStatusRule(options = {}) {
             failFinding(
               "run.status",
               "Run contains incomplete running events.",
-              running.map((event) => eventEvidence(event)),
+              running.map((event) => eventEvidence3(event)),
               "no running events",
               running.length
             )
@@ -5864,7 +7860,7 @@ function createMaxStepDurationRule(options) {
         failFinding(
           "run.maxStepDuration",
           `${over.length} step(s) exceeded max duration ${options.maxDurationMs}ms.`,
-          over.map((event) => eventEvidence(event, "durationMs")),
+          over.map((event) => eventEvidence3(event, "durationMs")),
           { maxDurationMs: options.maxDurationMs },
           over.map((event) => ({
             eventId: event.eventId,
@@ -5890,7 +7886,7 @@ function createStallDetectionRule(options = {}) {
           failFinding(
             "run.stall",
             `Found ${running.length} event(s) still running (possible stall).`,
-            running.map((event) => eventEvidence(event, "status")),
+            running.map((event) => eventEvidence3(event, "status")),
             "no running events",
             running.length
           )
@@ -5905,7 +7901,7 @@ function createStallDetectionRule(options = {}) {
             failFinding(
               "run.stall",
               `Found ${incomplete.length} started event(s) without endedAt.`,
-              incomplete.map((event) => eventEvidence(event, "endedAt")),
+              incomplete.map((event) => eventEvidence3(event, "endedAt")),
               "endedAt for started events",
               incomplete.length
             )
@@ -5941,7 +7937,7 @@ function createRequireCompletedRule() {
           failFinding(
             "run.requireCompleted",
             `Run has ${running.length} incomplete running event(s).`,
-            running.map((event) => eventEvidence(event, "status")),
+            running.map((event) => eventEvidence3(event, "status")),
             "no running events",
             running.length
           )
@@ -5992,8 +7988,26 @@ function createToolUsageRule(options) {
       const findings = [];
       for (const required of options.required ?? []) {
         if (!nameSet.has(required)) {
+          const otherKinds = [
+            ...new Set(
+              context.events.filter((event) => {
+                const kind = typeof event.kind === "string" ? event.kind.toUpperCase() : "";
+                if (kind === "TOOL") return false;
+                return resolveCanonicalToolName(event) === required || event.name === required || event.name === `tool:${required}` || event.name.endsWith(`:${required}`);
+              }).map(
+                (event) => typeof event.kind === "string" ? event.kind.toUpperCase() : "UNKNOWN"
+              )
+            )
+          ].sort();
+          const hint = otherKinds.length > 0 ? ` Required name appears under non-TOOL kind(s): ${otherKinds.join(", ")}. tools.required / requiredOrder match TOOL events only.` : "";
           findings.push(
-            failFinding("tool.usage", `Required tool ${required} did not appear.`, runEvidence(context.selectedRun), required, names)
+            failFinding(
+              "tool.usage",
+              `Required tool ${required} did not appear.${hint}`,
+              runEvidence(context.selectedRun),
+              required,
+              names
+            )
           );
         }
       }
@@ -6003,12 +8017,12 @@ function createToolUsageRule(options) {
         const name = toolName(event);
         if (forbidden.has(name)) {
           findings.push(
-            failFinding("tool.usage", `Forbidden tool ${name} appeared.`, [eventEvidence(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.`, [eventEvidence(event)], [...allowed].sort(), name)
+            failFinding("tool.usage", `Tool ${name} is not in the allowed tool set.`, [eventEvidence3(event)], [...allowed].sort(), name)
           );
         }
       }
@@ -6019,13 +8033,188 @@ 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) => eventEvidence(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;
     }
   };
 }
+function createToolOrderingRule(options) {
+  const ruleId = options.id ?? "tool.order";
+  const mode = options.mode ?? "first-occurrence";
+  return {
+    id: ruleId,
+    category: "tool",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const tools = finishedEvents(context, "TOOL");
+      const index = firstIndexByName(tools);
+      const beforeIndex = index.get(options.before);
+      const afterIndex = index.get(options.after);
+      if (beforeIndex === void 0 || afterIndex === void 0) {
+        return [];
+      }
+      if (mode === "first-occurrence" && beforeIndex >= afterIndex) {
+        return [
+          failFinding(
+            ruleId,
+            `Tool ${options.before} must appear before ${options.after}.`,
+            [eventEvidence3(tools[beforeIndex]), eventEvidence3(tools[afterIndex])],
+            { before: options.before, after: options.after },
+            tools.map(toolName)
+          )
+        ];
+      }
+      const beforeEvent = tools[beforeIndex];
+      const afterEvent = tools[afterIndex];
+      const beforeEnd = eventEndMs(beforeEvent);
+      const afterStart = eventStartMs(afterEvent);
+      if (mode === "happens-before") {
+        const expected = {
+          before: options.before,
+          after: options.after,
+          mode,
+          relation: "before.end <= after.start"
+        };
+        if (options.before === options.after) {
+          return [
+            failFinding(
+              ruleId,
+              `Tool ${options.before} cannot causally happen before itself.`,
+              [eventEvidence3(beforeEvent)],
+              expected,
+              { code: "tool.order.same-tool" }
+            )
+          ];
+        }
+        if (beforeEnd === void 0 || afterStart === void 0) {
+          return [
+            failFinding(
+              ruleId,
+              `Tool order ${options.before} before ${options.after} could not establish causal timing.`,
+              [eventEvidence3(beforeEvent), eventEvidence3(afterEvent)],
+              expected,
+              {
+                code: "tool.order.interval-unresolved",
+                beforeEndResolved: beforeEnd !== void 0,
+                afterStartResolved: afterStart !== void 0
+              }
+            )
+          ];
+        }
+        if (beforeEnd > afterStart) {
+          return [
+            failFinding(
+              ruleId,
+              `Tool ${options.before} must finish before ${options.after} starts.`,
+              [eventEvidence3(beforeEvent), eventEvidence3(afterEvent)],
+              expected,
+              {
+                beforeEndedAt: new Date(beforeEnd).toISOString(),
+                afterStartedAt: new Date(afterStart).toISOString()
+              }
+            )
+          ];
+        }
+        return [];
+      }
+      if (mode === "all-occurrences") {
+        const beforeEvents = tools.filter((event) => toolName(event) === options.before);
+        const afterEvents = tools.filter((event) => toolName(event) === options.after);
+        const expected = {
+          before: options.before,
+          after: options.after,
+          mode,
+          relation: "max(before.end) <= min(after.start)"
+        };
+        if (options.before === options.after) {
+          return [
+            failFinding(
+              ruleId,
+              `Tool ${options.before} cannot causally happen before itself.`,
+              [eventEvidence3(beforeEvent)],
+              expected,
+              { code: "tool.order.same-tool" }
+            )
+          ];
+        }
+        let latestBefore;
+        let earliestAfter;
+        let missingBeforeEnds = 0;
+        let missingAfterStarts = 0;
+        let firstMissingBefore;
+        let firstMissingAfter;
+        for (const event of beforeEvents) {
+          const end = eventEndMs(event);
+          if (end === void 0) {
+            missingBeforeEnds += 1;
+            firstMissingBefore ??= event;
+          } else if (latestBefore === void 0 || end > latestBefore.end) {
+            latestBefore = { event, end };
+          }
+        }
+        for (const event of afterEvents) {
+          const start = eventStartMs(event);
+          if (start === void 0) {
+            missingAfterStarts += 1;
+            firstMissingAfter ??= event;
+          } else if (earliestAfter === void 0 || start < earliestAfter.start) {
+            earliestAfter = { event, start };
+          }
+        }
+        if (missingBeforeEnds > 0 || missingAfterStarts > 0 || latestBefore === void 0 || earliestAfter === void 0) {
+          return [
+            failFinding(
+              ruleId,
+              `Tool order ${options.before} before ${options.after} could not establish all causal intervals.`,
+              [firstMissingBefore, firstMissingAfter].filter((event) => event !== void 0).map((event) => eventEvidence3(event)),
+              expected,
+              {
+                code: "tool.order.interval-unresolved",
+                missingBeforeEnds,
+                missingAfterStarts
+              }
+            )
+          ];
+        }
+        if (latestBefore.end > earliestAfter.start) {
+          return [
+            failFinding(
+              ruleId,
+              `Every ${options.before} tool call must finish before any ${options.after} tool call starts.`,
+              [eventEvidence3(latestBefore.event), eventEvidence3(earliestAfter.event)],
+              expected,
+              {
+                latestBeforeEndedAt: new Date(latestBefore.end).toISOString(),
+                earliestAfterStartedAt: new Date(earliestAfter.start).toISOString()
+              }
+            )
+          ];
+        }
+        return [];
+      }
+      if (beforeEnd !== void 0 && afterStart !== void 0 && beforeEnd > afterStart) {
+        return [
+          {
+            ruleId,
+            severity: "warning",
+            status: "warning",
+            message: `Tool order ${options.before} before ${options.after} satisfied start/encounter order, but intervals overlap so causal completion before the next tool was not established.`,
+            expected: { before: options.before, after: options.after, mode: "first-occurrence" },
+            actual: {
+              code: "tool.order.overlap",
+              beforeEndedAt: beforeEvent.endedAt,
+              afterStartedAt: afterEvent.startedAt ?? afterEvent.timestamp
+            },
+            evidence: [eventEvidence3(beforeEvent), eventEvidence3(afterEvent)]
+          }
+        ];
+      }
+      return [];
+    }
+  };
+}
 function createLlmUsageRule(options) {
   return {
     id: "llm.usage",
@@ -6042,7 +8231,7 @@ function createLlmUsageRule(options) {
           failFinding(
             "llm.usage",
             `LLM call count ${llms.length} exceeded ${options.maxCalls}.`,
-            llms.map((event) => eventEvidence(event)),
+            llms.map((event) => eventEvidence3(event)),
             { maxCalls: options.maxCalls },
             llms.length
           )
@@ -6054,17 +8243,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.`, [eventEvidence(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.`, [eventEvidence(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.`, [eventEvidence(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")
           );
         }
       }
@@ -6089,7 +8278,7 @@ function createLlmUsageRule(options) {
             failFinding(
               "llm.usage",
               `LLM ${key} token count ${tokenTotals[key]} exceeded ${limit}.`,
-              llms.map((event) => eventEvidence(event, `tokenUsage.${key}`)),
+              llms.map((event) => eventEvidence3(event, `tokenUsage.${key}`)),
               { [`max${key[0].toUpperCase()}${key.slice(1)}Tokens`]: limit },
               tokenTotals[key]
             )
@@ -6100,6 +8289,47 @@ function createLlmUsageRule(options) {
     }
   };
 }
+function createStructureIncompleteRule(options = {}) {
+  return {
+    id: "structure.incomplete",
+    category: "structure",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const findings = [];
+      if (!options.allowRunning) {
+        const running = semanticEvents(context).filter((event) => event.status === "running");
+        if (running.length > 0) {
+          findings.push(
+            failFinding(
+              "structure.incomplete",
+              "Trace contains incomplete running events.",
+              running.map((event) => eventEvidence3(event, "status")),
+              "no running events",
+              running.length
+            )
+          );
+        }
+      }
+      if (options.requireEndedAtForStarted) {
+        const missingEndedAt = semanticEvents(context).filter(
+          (event) => event.startedAt !== void 0 && event.endedAt === void 0 && event.status !== "running"
+        );
+        if (missingEndedAt.length > 0) {
+          findings.push(
+            failFinding(
+              "structure.incomplete",
+              "Trace contains events with startedAt but no endedAt.",
+              missingEndedAt.map((event) => eventEvidence3(event, "endedAt")),
+              "endedAt for started events",
+              missingEndedAt.length
+            )
+          );
+        }
+      }
+      return findings;
+    }
+  };
+}
 function createStructureOrphanRule(options = {}) {
   const allowMarkedUnresolved = options.allowMarkedUnresolved ?? true;
   return {
@@ -6117,7 +8347,7 @@ function createStructureOrphanRule(options = {}) {
         failFinding(
           "structure.orphan",
           "Trace contains events whose parentId is not present in the selected run.",
-          orphans.map((event) => eventEvidence(event, "parentId")),
+          orphans.map((event) => eventEvidence3(event, "parentId")),
           "parentId resolves to an event in the selected run",
           orphans.length
         )
@@ -6149,7 +8379,7 @@ function createStructureCycleRule() {
                 failFinding(
                   "structure.cycle",
                   formatProgrammaticDiagnostic("AI_TRACE_RELATIONSHIP_CYCLE"),
-                  cycle.map((item) => eventEvidence(item, "parentId")),
+                  cycle.map((item) => eventEvidence3(item, "parentId")),
                   "acyclic parentId graph",
                   cycle.map((item) => item.eventId).sort()
                 )
@@ -6189,7 +8419,7 @@ function createStructureRelationshipRule(options = {}) {
               failFinding(
                 "structure.relationship",
                 `Event confidence ${event.confidence} is below ${minConfidence}.`,
-                [eventEvidence(event, "confidence")],
+                [eventEvidence3(event, "confidence")],
                 { minConfidence },
                 event.confidence
               )
@@ -6202,7 +8432,7 @@ function createStructureRelationshipRule(options = {}) {
             failFinding(
               "structure.relationship",
               "Event parentId points to itself.",
-              [eventEvidence(event, "parentId")],
+              [eventEvidence3(event, "parentId")],
               "parentId references a distinct event",
               "self"
             )
@@ -6219,7 +8449,7 @@ function createStructureRelationshipRule(options = {}) {
               failFinding(
                 "structure.relationship",
                 "Parent event starts after child event.",
-                [eventEvidence(parent), eventEvidence(event, "parentId")],
+                [eventEvidence3(parent), eventEvidence3(event, "parentId")],
                 "parent start <= child start",
                 { parentEventId: parent.eventId, childEventId: event.eventId }
               )
@@ -6233,7 +8463,7 @@ function createStructureRelationshipRule(options = {}) {
               failFinding(
                 "structure.relationship",
                 "Trace parentSpanId does not match parent spanId.",
-                [eventEvidence(event, "trace.parentSpanId")],
+                [eventEvidence3(event, "trace.parentSpanId")],
                 { parentSpanId: parent.trace.spanId },
                 actual ?? "missing"
               )
@@ -6262,7 +8492,7 @@ function createStructureParallelWidthRule(options) {
               "structure.parallelWidth",
               `Parent ${parentId} has ${children.length} children, exceeding ${options.maxChildren}.`,
               [
-                ...parent ? [eventEvidence(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,
@@ -6310,7 +8540,7 @@ function createStructureParallelWidthRule(options) {
             failFinding(
               "structure.parallelWidth",
               `Concurrent event width ${maxActive.length} exceeded ${options.maxConcurrent}.`,
-              maxActive.map((event) => eventEvidence(event)),
+              maxActive.map((event) => eventEvidence3(event)),
               { maxConcurrent: options.maxConcurrent },
               maxActive.length
             )
@@ -6338,7 +8568,7 @@ function createSafetyRedactionRule(options = {}) {
             failFinding(
               "safety.redaction",
               `Sensitive-looking field at ${entry.path} is not redacted.`,
-              [eventEvidence(event, entry.path)],
+              [eventEvidence3(event, entry.path)],
               "redaction marker",
               { path: entry.path, valueType: valueType(entry.value) },
               {
@@ -6358,6 +8588,7 @@ function createSafetyRedactionRule(options = {}) {
 function createSafetyRawContentRule(options = {}) {
   const forbiddenKeys = options.forbiddenKeys ?? DEFAULT_RAW_CONTENT_KEYS;
   const safePathPrefixes = options.safePathPrefixes ?? DEFAULT_SAFE_RAW_CONTENT_PATH_PREFIXES;
+  const markers = options.redactedMarkers ?? ["[REDACTED]", "[REDACTED:"];
   return {
     id: "safety.rawPrompt",
     category: "safety",
@@ -6368,11 +8599,12 @@ function createSafetyRawContentRule(options = {}) {
         for (const entry of eventValueEntries(event, { includeSummaries: options.includeSummaries })) {
           const key = entry.key ?? lastPathSegment(entry.path);
           if (!isRawContentPath(entry.path, key, forbiddenKeys, safePathPrefixes)) continue;
+          if (isFullyRedactedValue(entry.value, markers)) continue;
           findings.push(
             failFinding(
               "safety.rawPrompt",
               `Raw content-like field ${entry.path} is present.`,
-              [eventEvidence(event, entry.path)],
+              [eventEvidence3(event, entry.path)],
               "metadata-only trace fields",
               { path: entry.path, valueType: valueType(entry.value) },
               {
@@ -6410,7 +8642,7 @@ function createSafetySecretPatternRule(options = {}) {
               failFinding(
                 "safety.secretPattern",
                 `Secret-like pattern ${pattern.id} matched at ${entry.path}.`,
-                [eventEvidence(event, entry.path)],
+                [eventEvidence3(event, entry.path)],
                 "no secret-like strings",
                 { pattern: pattern.id, path: entry.path },
                 {
@@ -6443,7 +8675,7 @@ function createSafetyOversizedAttributeRule(options) {
               failFinding(
                 "safety.oversizedAttribute",
                 `String at ${entry.path} exceeds ${options.maxStringLength} characters.`,
-                [eventEvidence(event, entry.path)],
+                [eventEvidence3(event, entry.path)],
                 { maxStringLength: options.maxStringLength },
                 { path: entry.path, length: entry.value.length },
                 {
@@ -6460,7 +8692,7 @@ function createSafetyOversizedAttributeRule(options) {
               failFinding(
                 "safety.oversizedAttribute",
                 `Array at ${entry.path} exceeds ${options.maxArrayLength} items.`,
-                [eventEvidence(event, entry.path)],
+                [eventEvidence3(event, entry.path)],
                 { maxArrayLength: options.maxArrayLength },
                 { path: entry.path, length: entry.value.length },
                 {
@@ -6477,7 +8709,7 @@ function createSafetyOversizedAttributeRule(options) {
               failFinding(
                 "safety.oversizedAttribute",
                 `Object at ${entry.path} exceeds ${options.maxObjectKeys} keys.`,
-                [eventEvidence(event, entry.path)],
+                [eventEvidence3(event, entry.path)],
                 { maxObjectKeys: options.maxObjectKeys },
                 { path: entry.path, keys: Object.keys(entry.value).length },
                 {
@@ -6496,7 +8728,7 @@ function createSafetyOversizedAttributeRule(options) {
                 failFinding(
                   "safety.oversizedAttribute",
                   `Value at ${entry.path} exceeds ${options.maxSerializedBytes} serialized bytes.`,
-                  [eventEvidence(event, entry.path)],
+                  [eventEvidence3(event, entry.path)],
                   { maxSerializedBytes: options.maxSerializedBytes },
                   { path: entry.path, bytes },
                   {
@@ -6623,7 +8855,7 @@ function createBaselineRegressionRule(options) {
           path: "guardrail",
           expected: guardrailShape(baselineContext),
           actual: guardrailShape(context),
-          evidence: guardrailEvents(context)[0] ? [eventEvidence(guardrailEvents(context)[0], "guardrail")] : runEvidence(context.selectedRun)
+          evidence: guardrailEvents(context)[0] ? [eventEvidence3(guardrailEvents(context)[0], "guardrail")] : runEvidence(context.selectedRun)
         }
       ];
       for (const comparison of comparisons) {
@@ -6702,7 +8934,7 @@ function runTraceChecks(input, options = {}) {
     return errorResult(
       input,
       [
-        diagnostic(
+        diagnostic2(
           "AI_CHECK_NO_RULES_EVALUATED",
           "No trace check rules were evaluated. Configure at least one rule, contract, or CLI check option."
         )
@@ -6733,7 +8965,7 @@ function runTraceChecks(input, options = {}) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       diagnostics.push(
-        diagnostic("AI_CHECK_INTERNAL_ERROR", `Rule ${rule.id} failed: ${message}`, rule.id)
+        diagnostic2("AI_CHECK_INTERNAL_ERROR", `Rule ${rule.id} failed: ${message}`, rule.id)
       );
       ruleExecutions.push({
         ruleId: rule.id,
@@ -6797,18 +9029,18 @@ function escapeMarkdown(value) {
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
-function sortKeysDeep(input) {
+function sortKeysDeep2(input) {
   if (input === null || typeof input !== "object") return input;
-  if (Array.isArray(input)) return input.map(sortKeysDeep);
+  if (Array.isArray(input)) return input.map(sortKeysDeep2);
   const o = input;
   const out = {};
   for (const k of Object.keys(o).sort()) {
-    out[k] = sortKeysDeep(o[k]);
+    out[k] = sortKeysDeep2(o[k]);
   }
   return out;
 }
 function stableJson(value, pretty) {
-  const sorted = sortKeysDeep(value);
+  const sorted = sortKeysDeep2(value);
   return pretty === true ? JSON.stringify(sorted, null, 2) : JSON.stringify(sorted);
 }
 function compactAttributes(attrs, options) {
@@ -8668,7 +10900,7 @@ var DEFAULT_SUITE_CONFIG_NAMES = [
   "agent-inspect.suite.cjs"
 ];
 var DEFAULT_SUITE_ARTIFACTS_DIR = ".agent-inspect/suite-runs";
-function diagnostic2(code, message, severity = "error", caseId) {
+function diagnostic3(code, message, severity = "error", caseId) {
   return { code, message, severity, ...caseId !== void 0 ? { caseId } : {} };
 }
 function asString(value, label) {
@@ -8696,7 +10928,7 @@ function validateCaseConfig(value, index) {
   const diagnostics = [];
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     diagnostics.push(
-      diagnostic2("AI_SUITE_CONFIG_INVALID", `cases[${index}] must be an object.`)
+      diagnostic3("AI_SUITE_CONFIG_INVALID", `cases[${index}] must be an object.`)
     );
     return { diagnostics };
   }
@@ -8705,7 +10937,7 @@ function validateCaseConfig(value, index) {
     const id = asString(raw.id, `cases[${index}].id`);
     if (id === void 0) {
       diagnostics.push(
-        diagnostic2("AI_SUITE_CONFIG_INVALID", `cases[${index}].id is required.`)
+        diagnostic3("AI_SUITE_CONFIG_INVALID", `cases[${index}].id is required.`)
       );
       return { diagnostics };
     }
@@ -8740,7 +10972,7 @@ function validateCaseConfig(value, index) {
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    diagnostics.push(diagnostic2("AI_SUITE_CONFIG_INVALID", message));
+    diagnostics.push(diagnostic3("AI_SUITE_CONFIG_INVALID", message));
     return { diagnostics };
   }
 }
@@ -8816,7 +11048,7 @@ async function validateSuiteConfig(config, options) {
     await access(tracesDir);
   } catch {
     diagnostics.push(
-      diagnostic2("AI_SUITE_CONFIG_INVALID", `traces directory not found: ${tracesDir}`)
+      diagnostic3("AI_SUITE_CONFIG_INVALID", `traces directory not found: ${tracesDir}`)
     );
   }
   for (const suiteCase of config.cases) {
@@ -8826,7 +11058,7 @@ async function validateSuiteConfig(config, options) {
         await access(inputPath);
       } catch {
         diagnostics.push(
-          diagnostic2(
+          diagnostic3(
             "AI_SUITE_CONFIG_INVALID",
             `input fixture not found: ${suiteCase.input}`,
             "warning",
@@ -8840,7 +11072,7 @@ async function validateSuiteConfig(config, options) {
 }
 var CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".js", ".mjs", ".cjs"]);
 var TS_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts"]);
-function diagnostic3(code, message) {
+function diagnostic4(code, message) {
   return { code, message, severity: "error" };
 }
 async function fileExists(filePath) {
@@ -8871,20 +11103,20 @@ async function loadSuiteConfig(options = {}) {
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw Object.assign(new Error(message), {
-      diagnostics: [diagnostic3("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+      diagnostics: [diagnostic4("AI_SUITE_CONFIG_LOAD_FAILED", message)]
     });
   }
   const extension = path7.extname(configPath);
   if (TS_CONFIG_EXTENSIONS.has(extension)) {
     const message = "TypeScript suite configs require an explicit precompiled JavaScript config or future --config-loader support.";
     throw Object.assign(new Error(message), {
-      diagnostics: [diagnostic3("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+      diagnostics: [diagnostic4("AI_SUITE_CONFIG_LOAD_FAILED", message)]
     });
   }
   if (!CONFIG_EXTENSIONS.has(extension)) {
     const message = "Unsupported suite config extension. Use .json, .js, .mjs, or .cjs.";
     throw Object.assign(new Error(message), {
-      diagnostics: [diagnostic3("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+      diagnostics: [diagnostic4("AI_SUITE_CONFIG_LOAD_FAILED", message)]
     });
   }
   try {
@@ -8904,7 +11136,7 @@ async function loadSuiteConfig(options = {}) {
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw Object.assign(new Error(message), {
-      diagnostics: [diagnostic3("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+      diagnostics: [diagnostic4("AI_SUITE_CONFIG_LOAD_FAILED", message)]
     });
   }
 }
@@ -9827,13 +12059,13 @@ function persistedEventsForParsedTrace(parsed) {
 function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isNonEmptyString4(value) {
+function isNonEmptyString5(value) {
   return typeof value === "string" && value.trim() !== "";
 }
 function readStringField(record, keys) {
   for (const key of keys) {
     const value = record[key];
-    if (isNonEmptyString4(value)) return value;
+    if (isNonEmptyString5(value)) return value;
   }
   return void 0;
 }
@@ -9967,7 +12199,7 @@ function parseUnixNanoToIso(value) {
   return void 0;
 }
 function parseIsoTime(value) {
-  if (!isNonEmptyString4(value)) return void 0;
+  if (!isNonEmptyString5(value)) return void 0;
   const ms = Date.parse(value);
   if (!Number.isFinite(ms)) return void 0;
   return new Date(ms).toISOString();
@@ -11177,7 +13409,7 @@ async function resolveSuiteCaseTrace(suiteCase, options) {
 }
 
 // packages/core/src/suite/run.ts
-function diagnostic4(code, message, severity = "error", caseId) {
+function diagnostic5(code, message, severity = "error", caseId) {
   return { code, message, severity, ...caseId !== void 0 ? { caseId } : {} };
 }
 function buildCaseRules(suiteCase, config) {
@@ -11241,7 +13473,7 @@ function validateExpectedObservations(suiteCase, read) {
     const match = outcomes.find((outcome) => outcome.name === name);
     if (!match) {
       diagnostics.push(
-        diagnostic4(
+        diagnostic5(
           "AI_SUITE_CASE_OBSERVATION_FAILED",
           `Expected observation "${name}" was not recorded.`,
           "error",
@@ -11252,7 +13484,7 @@ function validateExpectedObservations(suiteCase, read) {
     }
     if (match.status !== "passed") {
       diagnostics.push(
-        diagnostic4(
+        diagnostic5(
           "AI_SUITE_CASE_OBSERVATION_FAILED",
           `Observation "${name}" has status "${match.status}", expected "passed".`,
           "error",
@@ -11272,7 +13504,7 @@ async function runSuiteCase(suiteCase, config, options) {
       ...resolved.runId !== void 0 ? { runId: resolved.runId } : {},
       message: resolved.reason,
       diagnostics: [
-        diagnostic4(
+        diagnostic5(
           "AI_SUITE_CASE_TRACE_MISSING",
           resolved.reason ?? "Trace not found.",
           "warning",
@@ -11293,7 +13525,7 @@ async function runSuiteCase(suiteCase, config, options) {
       ...resolved.runId !== void 0 ? { runId: resolved.runId } : {},
       message,
       diagnostics: [
-        diagnostic4("AI_SUITE_TRACE_UNREADABLE", message, "error", suiteCase.id)
+        diagnostic5("AI_SUITE_TRACE_UNREADABLE", message, "error", suiteCase.id)
       ]
     };
   }
@@ -11307,7 +13539,7 @@ async function runSuiteCase(suiteCase, config, options) {
   const observationResult = validateExpectedObservations(suiteCase, read);
   const diagnostics = [
     ...checkResult.diagnostics.map(
-      (item) => diagnostic4(
+      (item) => diagnostic5(
         "AI_SUITE_CASE_CHECK_FAILED",
         item.message,
         item.severity,
@@ -11315,7 +13547,7 @@ async function runSuiteCase(suiteCase, config, options) {
       )
     ),
     ...checkResult.findings.filter((finding) => finding.status === "fail").map(
-      (finding) => diagnostic4(
+      (finding) => diagnostic5(
         "AI_SUITE_CASE_CHECK_FAILED",
         finding.message,
         finding.severity,
@@ -12500,6 +14732,6 @@ function renderGateReport(result, options = {}) {
   return renderGateSummaryMarkdown(result);
 }
 
-export { ATTRIBUTION_CONFIDENCES, COHORT_METRIC_IDS, DEFAULT_SUITE_ARTIFACTS_DIR, EVIDENCE_FORMAT_VERSION, EVIDENCE_HTML_FILENAME, EVIDENCE_MANIFEST_FILENAME, Redactor, TraceDirectory, TraceReadError, TreeBuilder, aggregateBundleSafeStatus, aggregateSessionCheckResults, analyzeCohort, applyProfileMetadataCaps, assertBundlePathContained, assertEvidenceRelativePath, buildActivitySummary, buildBundleMetadata, buildBundleSummaryMarkdown, buildEvidenceCausalFailureViewHtml, buildEvidenceCiPackage, buildEvidenceCircuitViewHtml, buildEvidenceContractsViewHtml, buildEvidenceDiffViewHtml, buildEvidenceHtmlShell, buildEvidenceManifest, buildEvidenceOutcomesViewHtml, buildEvidenceProvenanceViewHtml, buildEvidenceSafetyViewHtml, buildEvidenceTimelineViewHtml, buildEvidenceToolsLlmViewHtml, buildEvidenceTreeViewHtml, buildLocalExplanation, buildPlaceholderArtifact, buildRunSummary, buildRunTimeline, buildRunWhatSummary, buildSessionIndex, buildTraceStats, buildZipArchive, bundleFailsOnSafety, bundleRunAssetRelativePath, collectTraceSchemaVersions, compactAttributes, createBaselineRegressionRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRunDepthRule, createRunDurationRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStructureCycleRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolUsageRule, defaultBundleOutputPath, defaultSuiteConfigTemplate, diffRuns, diffTraceEvents, enrichSessionRunRecord, escapeHtml, escapeMarkdown, extractMetadata, extractOutcomesFromTraceEvents, filterMetasBySessionScope, filterTraces, flattenTree, formatDuration2 as formatDuration, formatStepLabel, formatTimestamp, gateHasThresholds, getIndent, getTraceFilePath, inferEvidenceFileRole, isAgentInspectTrace, isAttributionConfidence, isPersistedInspectEvent, loadSessionRunRecords, loadSuiteConfig, loadTraceMetadataList, manualTraceEventsToComparableRun, nanoid, normalizeBundleOutputPath, openTrace, parseCohortMetricList, parseDuration, parseDurationFilter, parseGateList, parseTraceJsonl, persistedInspectEventsToTraceEvents, projectLogicalEvents, renderActivitySummaryHuman, renderCohortReport, renderErrorLine, renderGateReport, renderObservedOutcomesHtml, renderObservedOutcomesMarkdown, renderRunDiff, renderRunWhat, renderStepLine, renderSuiteReport, renderTimeline, renderTraceStats, resolveBundleRunIds, resolveRedactionProfile, resolveSuiteTemplate, resolveTraceDir, runGate, runSuite, runTraceChecks, safeString, sanitizeBundleRunId, searchTraces, serializeEvidenceManifest, sha256Hex, stableJson, summarizeObservedOutcomes, summarizeSemanticParity, traceEventToPersistedInspectEvent, truncateName, truncateStringForProfile, validateEvent, validateSuiteConfig, verifyEvidenceDirectory, zeroKinds };
-//# sourceMappingURL=chunk-XWQEHKGB.mjs.map
-//# sourceMappingURL=chunk-XWQEHKGB.mjs.map
+export { ATTRIBUTION_CONFIDENCES, COHORT_METRIC_IDS, DEFAULT_SUITE_ARTIFACTS_DIR, EVIDENCE_FORMAT_VERSION, EVIDENCE_HTML_FILENAME, EVIDENCE_MANIFEST_FILENAME, Redactor, TraceDirectory, TraceReadError, TreeBuilder, aggregateBundleSafeStatus, aggregateSessionCheckResults, analyzeCohort, applyProfileMetadataCaps, assertBundlePathContained, assertEvidenceRelativePath, buildActivitySummary, buildBundleMetadata, buildBundleSummaryMarkdown, buildEvidenceCausalFailureViewHtml, buildEvidenceCiPackage, buildEvidenceCircuitViewHtml, buildEvidenceContractsViewHtml, buildEvidenceDiffViewHtml, buildEvidenceHtmlShell, buildEvidenceManifest, buildEvidenceOutcomesViewHtml, buildEvidenceProvenanceViewHtml, buildEvidenceSafetyViewHtml, buildEvidenceTimelineViewHtml, buildEvidenceToolsLlmViewHtml, buildEvidenceTreeViewHtml, buildLocalExplanation, buildPlaceholderArtifact, buildRunSummary, buildRunTimeline, buildRunWhatSummary, buildSessionIndex, buildTraceStats, buildZipArchive, bundleFailsOnSafety, bundleRunAssetRelativePath, collectTraceSchemaVersions, compactAttributes, createBaselineRegressionRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRunDepthRule, createRunDurationRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStructureCycleRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolUsageRule, defaultBundleOutputPath, defaultSuiteConfigTemplate, defineTraceContract, diffRuns, diffTraceEvents, enrichSessionRunRecord, escapeHtml, escapeMarkdown, evaluateTraceContract, extractMetadata, extractOutcomesFromTraceEvents, filterMetasBySessionScope, filterTraces, flattenTree, formatDuration2 as formatDuration, formatStepLabel, formatTimestamp, gateHasThresholds, getIndent, getTraceFilePath, inferEvidenceFileRole, isAgentInspectTrace, isAttributionConfidence, isPersistedInspectEvent, loadSessionRunRecords, loadSuiteConfig, loadTraceMetadataList, manualTraceEventsToComparableRun, nanoid, normalizeBundleOutputPath, openTrace, parseCohortMetricList, parseDuration, parseDurationFilter, parseGateList, parseTraceJsonl, persistedInspectEventsToTraceEvents, projectLogicalEvents, renderActivitySummaryHuman, renderCohortReport, renderErrorLine, renderGateReport, renderObservedOutcomesHtml, renderObservedOutcomesMarkdown, renderRunDiff, renderRunWhat, renderStepLine, renderSuiteReport, renderTimeline, renderTraceStats, resolveBundleRunIds, resolveRedactionProfile, resolveSuiteTemplate, resolveTraceDir, runGate, runSuite, runTraceChecks, safeString, sanitizeBundleRunId, searchTraces, serializeEvidenceManifest, sha256Hex, stableJson, summarizeObservedOutcomes, summarizeSemanticParity, traceEventToPersistedInspectEvent, truncateName, truncateStringForProfile, validateEvent, validateSuiteConfig, verifyEvidenceDirectory, zeroKinds };
+//# sourceMappingURL=chunk-BDRJENLM.mjs.map
+//# sourceMappingURL=chunk-BDRJENLM.mjs.map