agent-inspect 6.29.6 → 6.30.0

package/packages/cli/dist/index.cjs

@@ -3388,7 +3388,7 @@ function deriveLastError(runs) {
 }
 function deriveCheckSummary(runs) {
   let pass2 = 0;
-  let fail4 = 0;
+  let fail7 = 0;
   let warn2 = 0;
   let found = false;
   for (const run of runs) {
@@ -3400,7 +3400,7 @@ function deriveCheckSummary(runs) {
       found = true;
     }
     if (typeof record.fail === "number") {
-      fail4 += record.fail;
+      fail7 += record.fail;
       found = true;
     }
     if (typeof record.warn === "number") {
@@ -3408,7 +3408,7 @@ function deriveCheckSummary(runs) {
       found = true;
     }
   }
-  return found ? { pass: pass2, fail: fail4, warn: warn2 } : void 0;
+  return found ? { pass: pass2, fail: fail7, warn: warn2 } : void 0;
 }
 function deriveObservationSummary(runs) {
   for (const run of [...runs].sort((a, b) => activityMs(b) - activityMs(a))) {
@@ -5726,6 +5726,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);
 }
@@ -6196,6 +6204,181 @@ function createToolUsageRule(options) {
     }
   };
 }
+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}.`,
+            [eventEvidence(tools[beforeIndex]), eventEvidence(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.`,
+              [eventEvidence(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.`,
+              [eventEvidence(beforeEvent), eventEvidence(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.`,
+              [eventEvidence(beforeEvent), eventEvidence(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.`,
+              [eventEvidence(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) => eventEvidence(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.`,
+              [eventEvidence(latestBefore.event), eventEvidence(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: [eventEvidence(beforeEvent), eventEvidence(afterEvent)]
+          }
+        ];
+      }
+      return [];
+    }
+  };
+}
 function createLlmUsageRule(options) {
   return {
     id: "llm.usage",
@@ -6270,6 +6453,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) => eventEvidence(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) => eventEvidence(event, "endedAt")),
+              "endedAt for started events",
+              missingEndedAt.length
+            )
+          );
+        }
+      }
+      return findings;
+    }
+  };
+}
 function createStructureOrphanRule(options = {}) {
   const allowMarkedUnresolved = options.allowMarkedUnresolved ?? true;
   return {
@@ -7035,6 +7259,198 @@ var init_checks2 = __esm({
 });
 
 // packages/core/src/checks/contract-scope.ts
+function diagnostic2(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 flattenNodes2(nodes) {
+  return nodes.flatMap((node) => [node, ...flattenNodes2(node.children)]);
+}
+function collectSubtreeEventIds(run, rootEventId) {
+  const nodes = flattenNodes2(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(input3, run, eventIds) {
+  const runEvents = input3.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: flattenNodes2(projectedChildren).length
+    }
+  };
+  return {
+    evidenceEventCount: projectedEvents.length,
+    input: {
+      ...input3,
+      selectedRun: projectedRun,
+      read: {
+        ...input3.read,
+        runs: [projectedRun],
+        events: projectedEvents
+      }
+    }
+  };
+}
+function resolveTraceContractScope(input3, scope) {
+  if (scope === void 0) {
+    return { diagnostics: [] };
+  }
+  const entries = scopeEntries(scope);
+  if (entries.length === 0) {
+    return {
+      diagnostics: [
+        diagnostic2(
+          "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 = [...input3.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 meta2 = workflowMetadataForRun(input3.read.events, run2.runId);
+      const actual = meta2[key];
+      return actual === value;
+    });
+  }
+  if (rootEventId && actorKeys.length === 0) {
+    candidates = candidates.filter(
+      (run2) => flattenNodes2(run2.children).some((node) => node.event.eventId === rootEventId)
+    );
+  }
+  if (candidates.length === 0) {
+    return {
+      diagnostics: [
+        diagnostic2(
+          "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: [
+        diagnostic2(
+          "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: [
+          diagnostic2(
+            "AI_CHECK_INVALID_ARGUMENTS",
+            `TraceContract scope rootEventId ${rootEventId} was not found in run ${run.runId}.`,
+            "contract.scope.root-missing"
+          )
+        ]
+      };
+    }
+  }
+  const projected = projectInput(input3, run, eventIds);
+  return {
+    resolved: {
+      runId: run.runId,
+      ...rootEventId !== void 0 ? { rootEventId } : {},
+      matchedSelectors,
+      evidenceEventCount: projected.evidenceEventCount,
+      input: projected.input
+    },
+    diagnostics: []
+  };
+}
 var init_contract_scope = __esm({
   "packages/core/src/checks/contract-scope.ts"() {
     init_metadata();
@@ -7042,6 +7458,146 @@ var init_contract_scope = __esm({
 });
 
 // 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;
+}
 var init_control_rules = __esm({
   "packages/core/src/checks/control-rules.ts"() {
     init_logical_events();
@@ -7049,19 +7605,539 @@ var init_control_rules = __esm({
 });
 
 // packages/core/src/checks/canonical-equality.ts
+function sortKeysDeep(input3, depth, maxDepth) {
+  if (depth > maxDepth) {
+    throw new Error("AI_CHECK_CANONICAL_DEPTH_EXCEEDED");
+  }
+  if (input3 === null || typeof input3 !== "object") return input3;
+  if (Array.isArray(input3)) {
+    return input3.map((item) => sortKeysDeep(item, depth + 1, maxDepth));
+  }
+  const record = input3;
+  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 };
+}
+var DEFAULT_MAX_DEPTH, DEFAULT_MAX_BYTES;
 var init_canonical_equality = __esm({
   "packages/core/src/checks/canonical-equality.ts"() {
+    DEFAULT_MAX_DEPTH = 8;
+    DEFAULT_MAX_BYTES = 16384;
   }
 });
 
 // packages/core/src/checks/tool-arguments.ts
-var init_tool_arguments = __esm({
-  "packages/core/src/checks/tool-arguments.ts"() {
-    init_canonical_equality();
+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.`
+  };
+}
+var init_tool_arguments = __esm({
+  "packages/core/src/checks/tool-arguments.ts"() {
+    init_canonical_equality();
   }
 });
 
 // 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 eventEvidence2(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 attemptNumber2 = 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 (attemptNumber2 !== void 0) {
+    if (attemptNumber2 > 1) {
+      return { kind: "retry" };
+    }
+    if (attemptNumber2 === 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 list2 = byOperation.get(operationId) ?? [];
+    list2.push(event);
+    byOperation.set(operationId, list2);
+  }
+  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(eventEvidence2),
+            "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(eventEvidence2),
+            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(eventEvidence2),
+            "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.`,
+            [eventEvidence2(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 list2 = byToolOp.get(key) ?? [];
+      list2.push(event);
+      byToolOp.set(key, list2);
+    }
+    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.`,
+              [eventEvidence2(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.`,
+              [eventEvidence2(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.`,
+              [eventEvidence2(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 meta2 = workflowFor(event);
+        return meta2.attemptId !== void 0 || meta2.attemptNumber !== void 0 || meta2.attempt !== void 0 || meta2.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(eventEvidence2),
+            "earlier error then later ok",
+            {
+              sawEarlierError,
+              statuses: toolish.map((event) => event.status)
+            }
+          )
+        );
+      }
+    }
+  }
+  return findings;
+}
 var init_retry_safety = __esm({
   "packages/core/src/checks/retry-safety.ts"() {
     init_logical_events();
@@ -7070,6 +8146,478 @@ var init_retry_safety = __esm({
 });
 
 // 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 eventEvidence3(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 list2 = groups.get(key) ?? [];
+    list2.push(event);
+    groups.set(key, list2);
+  }
+  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(eventEvidence3),
+            "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(eventEvidence3),
+              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.`,
+                [eventEvidence3(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}).`,
+              [eventEvidence3(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.`,
+                [eventEvidence3(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.`,
+                  [eventEvidence3(event), eventEvidence3(lastError)],
+                  [...allowed],
+                  code ?? null
+                )
+              );
+            }
+          } else {
+            findings.push(
+              fail3(
+                "contract.retry.operations.retryable-error",
+                `Retry of tool ${operation.tool} has no prior error code evidence.`,
+                [eventEvidence3(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,
+                  [eventEvidence3(baseline), eventEvidence3(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.",
+                [eventEvidence3(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(eventEvidence3),
+              "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(eventEvidence3),
+              "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.`,
+                [eventEvidence3(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.`,
+                  [eventEvidence3(successForDependency)],
+                  "LLM reference to successful tool event",
+                  { code: "AI_CHECK_RECOVERY_RESULT_DEPENDENCY_MISSING" }
+                )
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  return findings;
+}
 var init_recovery_operations = __esm({
   "packages/core/src/checks/recovery-operations.ts"() {
     init_canonical_equality();
@@ -7081,6 +8629,23 @@ var init_recovery_operations = __esm({
 });
 
 // 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 } } : {},
@@ -7133,6 +8698,441 @@ function cloneBody(body) {
 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;
 }
+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)];
+      }
+    });
+  }
+  return rules;
+}
 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() !== "";
@@ -7233,6 +9233,57 @@ function validateAlternativesShape(alternatives) {
   }
   return diagnostics;
 }
+function emptyPassResult(input3, runId) {
+  return {
+    ok: true,
+    status: "pass",
+    format: input3.read.format,
+    ...runId !== void 0 ? { runId } : {},
+    summary: { passed: 0, failed: 0, warnings: 0, errors: 0, rulesEvaluated: 0 },
+    findings: [],
+    diagnostics: [],
+    ruleExecutions: []
+  };
+}
+function mergeContractResults(input3, 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: input3.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(input3, body, options = {}) {
+  const rules = contractToRules(body);
+  if (rules.length === 0) {
+    return emptyPassResult(input3, options.runId);
+  }
+  return runTraceChecks(input3, {
+    rules,
+    ...options.runId !== void 0 ? { runId: options.runId } : {}
+  });
+}
 function defineTraceContract(input3) {
   const shapeErrors = [
     ...validateAlternativesShape(input3.alternatives),
@@ -7263,6 +9314,144 @@ function defineTraceContract(input3) {
     ...alternatives ? { alternatives } : {}
   };
 }
+function evaluateTraceContract(input3, 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: input3.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(input3, contract.scope);
+  if (scoped.diagnostics.length > 0) {
+    return {
+      ok: false,
+      status: "error",
+      format: input3.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 ?? input3;
+  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]
+  );
+}
+var MAX_EVIDENCE_EVENT_IDS, METHOD_VOCABULARY;
 var init_contract = __esm({
   "packages/core/src/checks/contract.ts"() {
     init_checks2();
@@ -7275,7 +9464,8 @@ var init_contract = __esm({
     init_outcomes();
     init_contract_scope();
     init_tool_arguments();
-    new Set(OBSERVED_OUTCOME_METHODS);
+    MAX_EVIDENCE_EVENT_IDS = 16;
+    METHOD_VOCABULARY = new Set(OBSERVED_OUTCOME_METHODS);
   }
 });
 
@@ -7650,18 +9840,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(input3) {
+function sortKeysDeep2(input3) {
   if (input3 === null || typeof input3 !== "object") return input3;
-  if (Array.isArray(input3)) return input3.map(sortKeysDeep);
+  if (Array.isArray(input3)) return input3.map(sortKeysDeep2);
   const o = input3;
   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) {
@@ -9294,7 +11484,7 @@ var init_types5 = __esm({
     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) {
@@ -9322,7 +11512,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 };
   }
@@ -9331,7 +11521,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 };
     }
@@ -9366,7 +11556,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 };
   }
 }
@@ -9442,7 +11632,7 @@ async function validateSuiteConfig(config, options) {
     await promises.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) {
@@ -9452,7 +11642,7 @@ async function validateSuiteConfig(config, options) {
         await promises.access(inputPath);
       } catch {
         diagnostics.push(
-          diagnostic2(
+          diagnostic3(
             "AI_SUITE_CONFIG_INVALID",
             `input fixture not found: ${suiteCase.input}`,
             "warning",
@@ -9468,7 +11658,7 @@ var init_validate2 = __esm({
   "packages/core/src/suite/validate.ts"() {
   }
 });
-function diagnostic3(code, message) {
+function diagnostic4(code, message) {
   return { code, message, severity: "error" };
 }
 async function fileExists(filePath) {
@@ -9499,20 +11689,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 = path33__default.default.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 {
@@ -9532,7 +11722,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)]
     });
   }
 }
@@ -10459,13 +12649,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;
 }
@@ -10599,7 +12789,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();
@@ -11856,7 +14046,7 @@ var init_readers = __esm({
     ];
   }
 });
-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) {
@@ -11920,7 +14110,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",
@@ -11931,7 +14121,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",
@@ -11951,7 +14141,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",
@@ -11972,7 +14162,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)
       ]
     };
   }
@@ -11986,7 +14176,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,
@@ -11994,7 +14184,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,
@@ -13811,7 +16001,7 @@ var init_src = __esm({
 });
 
 // package.json
-var version = "6.29.6";
+var version = "6.30.0";
 
 // packages/cli/src/list.ts
 init_advanced();
@@ -18660,10 +20850,10 @@ function buildSafetyRules(options) {
     })
   ];
 }
-function flattenNodes2(nodes) {
+function flattenNodes3(nodes) {
   return nodes.flatMap((node) => [
     node,
-    ...flattenNodes2(
+    ...flattenNodes3(
       node.children
     )
   ]);
@@ -18698,7 +20888,7 @@ function redactionDetectorFindings(read, runId, policy) {
   const out = [];
   const policyOptions = redactionOptionsFromPolicy(policy);
   for (const run of runs) {
-    for (const node of flattenNodes2(run.children)) {
+    for (const node of flattenNodes3(run.children)) {
       const attrs = node.event.attributes;
       if (attrs === void 0) continue;
       const result = createRedactor({
@@ -18838,8 +21028,8 @@ function printHuman(result, explain = false) {
   console.log(
     `Summary: ${result.summary.findings} finding(s), ${result.summary.warnings} warning(s), ${result.summary.errors} error(s)`
   );
-  for (const diagnostic7 of result.diagnostics) {
-    console.log(`- ${diagnostic7.code}: ${diagnostic7.message}`);
+  for (const diagnostic8 of result.diagnostics) {
+    console.log(`- ${diagnostic8.code}: ${diagnostic8.message}`);
   }
   for (const finding of result.findings) {
     const path44 = finding.evidence[0]?.path;
@@ -19756,7 +21946,8 @@ async function writeLocalEvidence(input3) {
     redactionProfile: profile,
     assessmentStatus,
     checkResultsJson: input3.checkResultsJson,
-    ...input3.summaryText !== void 0 ? { summaryText: input3.summaryText } : {}
+    ...input3.summaryText !== void 0 ? { summaryText: input3.summaryText } : {},
+    ...input3.contractPackage !== void 0 ? { contractPackage: input3.contractPackage } : {}
   });
   const files = [
     ["evidence.html", evidencePackage["evidence.html"]],
@@ -19764,6 +21955,10 @@ async function writeLocalEvidence(input3) {
     ["check-results.json", evidencePackage["check-results.json"]],
     ["trace.jsonl", evidencePackage["trace.jsonl"]]
   ];
+  const resolvedContract = evidencePackage["contract.resolved.json"];
+  if (resolvedContract !== void 0) {
+    files.push(["contract.resolved.json", resolvedContract]);
+  }
   const expected = createEvidenceCiArtifacts({
     redactionProfile: profile
   }).map((a) => a.path);
@@ -20073,7 +22268,7 @@ var DEFAULT_INJECTION_PATTERNS = [
 function pass(ruleId, message) {
   return { ruleId, status: "pass", severity: "info", message, evidence: [] };
 }
-function fail(ruleId, message, evidence, severity = "error") {
+function fail4(ruleId, message, evidence, severity = "error") {
   return { ruleId, status: severity === "warning" ? "warn" : "fail", severity, message, evidence };
 }
 function boundedPreview(value, max = 80) {
@@ -20093,7 +22288,7 @@ function evaluateBannedPhrase(text, options) {
   if (evidence.length === 0) {
     return pass(ruleId, "No banned phrases matched.");
   }
-  return fail(ruleId, `Matched ${evidence.length} banned phrase(s).`, evidence);
+  return fail4(ruleId, `Matched ${evidence.length} banned phrase(s).`, evidence);
 }
 var SEVERITY_RANK2 = { info: 0, warning: 1, error: 2 };
 function evaluatePiiLeak(value, options = {}) {
@@ -20112,7 +22307,7 @@ function evaluatePiiLeak(value, options = {}) {
     detector: finding.detector,
     preview: finding.preview
   }));
-  return fail(ruleId, `Detected ${findings.length} PII-style finding(s).`, evidence);
+  return fail4(ruleId, `Detected ${findings.length} PII-style finding(s).`, evidence);
 }
 function measureDepth(value) {
   if (value === null || typeof value !== "object") return 0;
@@ -20150,7 +22345,7 @@ function evaluateUnsafeToolArgs(toolName2, toolArgs2, options = {}) {
   if (evidence.length === 0) {
     return pass(ruleId, "Tool arguments within configured bounds.");
   }
-  return fail(ruleId, "Unsafe or oversized tool arguments detected.", evidence);
+  return fail4(ruleId, "Unsafe or oversized tool arguments detected.", evidence);
 }
 function evaluatePromptInjection(text, options = {}) {
   const ruleId = "guardrail.prompt-injection";
@@ -20166,7 +22361,7 @@ function evaluatePromptInjection(text, options = {}) {
   if (evidence.length === 0) {
     return pass(ruleId, "No prompt-injection patterns matched.");
   }
-  return fail(ruleId, `Matched ${evidence.length} injection pattern(s).`, evidence, "warning");
+  return fail4(ruleId, `Matched ${evidence.length} injection pattern(s).`, evidence, "warning");
 }
 function validateSchemaField(value, field, path44, evidence) {
   const ruleId = "guardrail.structured-output";
@@ -20192,7 +22387,7 @@ function validateSchemaField(value, field, path44, evidence) {
 function evaluateStructuredOutput(value, options) {
   const ruleId = "guardrail.structured-output";
   if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return fail(ruleId, "Structured output must be an object.", [
+    return fail4(ruleId, "Structured output must be an object.", [
       { ruleId, preview: typeof value }
     ]);
   }
@@ -20204,7 +22399,7 @@ function evaluateStructuredOutput(value, options) {
   if (evidence.length === 0) {
     return pass(ruleId, "Structured output matches schema subset.");
   }
-  return fail(ruleId, "Structured output schema violation.", evidence);
+  return fail4(ruleId, "Structured output schema violation.", evidence);
 }
 function evaluateOversizeOutput(value, options = {}) {
   const ruleId = "guardrail.oversize-output";
@@ -20213,7 +22408,7 @@ function evaluateOversizeOutput(value, options = {}) {
   if (text.length <= maxLength) {
     return pass(ruleId, "Output within size limits.");
   }
-  return fail(ruleId, `Output exceeds max length (${text.length} > ${maxLength}).`, [
+  return fail4(ruleId, `Output exceeds max length (${text.length} > ${maxLength}).`, [
     { ruleId, preview: `length=${text.length}` }
   ]);
 }
@@ -20224,11 +22419,11 @@ function evaluateRequiredJsonShape(value, options) {
     try {
       parsed = JSON.parse(value);
     } catch {
-      return fail(ruleId, "Value is not valid JSON.", [{ ruleId, preview: boundedPreview(value) }]);
+      return fail4(ruleId, "Value is not valid JSON.", [{ ruleId, preview: boundedPreview(value) }]);
     }
   }
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return fail(ruleId, "JSON value must be an object.", [{ ruleId, preview: typeof parsed }]);
+    return fail4(ruleId, "JSON value must be an object.", [{ ruleId, preview: typeof parsed }]);
   }
   const record = parsed;
   const evidence = [];
@@ -20240,7 +22435,7 @@ function evaluateRequiredJsonShape(value, options) {
   if (evidence.length === 0) {
     return pass(ruleId, "Required JSON keys present.");
   }
-  return fail(ruleId, "Missing required JSON keys.", evidence);
+  return fail4(ruleId, "Missing required JSON keys.", evidence);
 }
 
 // packages/guardrails/src/run.ts
@@ -20688,11 +22883,11 @@ function resolvePreset(preset, context = {}) {
 }
 var CONFIG_EXTENSIONS2 = /* @__PURE__ */ new Set([".json", ".js", ".mjs", ".cjs"]);
 var TS_CONFIG_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".mts", ".cts"]);
-function diagnostic5(code, message, severity = "error") {
+function diagnostic6(code, message, severity = "error") {
   return { code, message, severity };
 }
 function errorResult2(code, message, format = "unknown") {
-  const diagnostics = [diagnostic5(code, message)];
+  const diagnostics = [diagnostic6(code, message)];
   return {
     ok: false,
     status: "error",
@@ -20725,6 +22920,131 @@ function asStringArray2(value) {
   return value;
 }
 var CHECKS_KEYS = /* @__PURE__ */ new Set(["select", "run", "tool", "llm", "structure", "safety"]);
+var ROOT_CONFIG_KEYS = /* @__PURE__ */ new Set(["checks", "contract"]);
+var CONTRACT_KEYS = /* @__PURE__ */ new Set([
+  "run",
+  "tools",
+  "llm",
+  "observations",
+  "scope",
+  "alternatives",
+  "controls",
+  "retry"
+]);
+var CONTRACT_BODY_KEYS = /* @__PURE__ */ new Set([
+  "run",
+  "tools",
+  "llm",
+  "observations",
+  "controls",
+  "retry"
+]);
+var CONTRACT_SCOPE_KEYS = /* @__PURE__ */ new Set([
+  "runId",
+  "subAgentId",
+  "groupId",
+  "workflowStep",
+  "rootEventId"
+]);
+var CONTRACT_RUN_KEYS = /* @__PURE__ */ new Set(["requireCompleted", "allowedStatuses", "maxDurationMs"]);
+var CONTRACT_TOOLS_KEYS = /* @__PURE__ */ new Set([
+  "required",
+  "requiredTools",
+  "forbidden",
+  "forbiddenTools",
+  "allowed",
+  "maxCalls",
+  "requiredOrder",
+  "requiredOrderMode",
+  "arguments",
+  "orderRules",
+  "defaultOccurrenceMode"
+]);
+var CONTRACT_LLM_KEYS = /* @__PURE__ */ new Set(["maxCalls", "maxTotalTokens", "allowedModels"]);
+var CONTRACT_OBSERVATION_KEYS = /* @__PURE__ */ new Set(["required", "failOn", "requireProvenance"]);
+var CONTRACT_PROVENANCE_KEYS = /* @__PURE__ */ new Set(["method", "evidence", "sameRunEventReference"]);
+var CONTRACT_CONTROLS_KEYS = /* @__PURE__ */ new Set([
+  "declaredTools",
+  "enforcedTools",
+  "declaredToolsAttribute",
+  "enforcedToolsAttribute",
+  "requireDeclaredMatchesEnforced",
+  "requireObservedWithinEnforced",
+  "requireObservedWithinDeclared",
+  "requiredStages"
+]);
+var CONTRACT_CONTROL_STAGES = /* @__PURE__ */ new Set([
+  "declared",
+  "presented",
+  "validated",
+  "enforced",
+  "observed",
+  "accepted"
+]);
+var CONTRACT_CONTROL_STAGE_KEYS = /* @__PURE__ */ new Set(["stage", "observation"]);
+var CONTRACT_RETRY_KEYS = /* @__PURE__ */ new Set([
+  "maxAttempts",
+  "requireTerminalResult",
+  "fallbackOnlyAfterFailure",
+  "nonIdempotentTools",
+  "requireIdempotencyEvidenceForRetry",
+  "requireRecoveredFailureVisible",
+  "operations"
+]);
+var CONTRACT_OPERATION_KEYS = /* @__PURE__ */ new Set([
+  "tool",
+  "maxAttempts",
+  "retryableErrors",
+  "requireFailureBeforeRetry",
+  "requireSameArguments",
+  "requireTerminalSuccess",
+  "requireRecoveredFailureVisible",
+  "successfulResultDependency",
+  "sideEffectClass"
+]);
+var CONTRACT_RETRYABLE_ERRORS_KEYS = /* @__PURE__ */ new Set(["codes"]);
+var CONTRACT_RESULT_DEP_KEYS = /* @__PURE__ */ new Set(["consumerKind", "requireExplicitReference"]);
+var CONTRACT_ALT_KEYS = /* @__PURE__ */ new Set(["anyOf"]);
+var CONTRACT_ALT_BRANCH_KEYS = /* @__PURE__ */ new Set(["id", "description", "contract"]);
+var CONTRACT_ORDER_RULE_KEYS = /* @__PURE__ */ new Set([
+  "before",
+  "after",
+  "occurrenceMode",
+  "requireEndpoints"
+]);
+var CONTRACT_ARGUMENT_KEYS = /* @__PURE__ */ new Set([
+  "tool",
+  "path",
+  "operator",
+  "occurrence",
+  "expected",
+  "oneOf",
+  "type"
+]);
+var CONTRACT_ARGUMENT_OPERATORS = /* @__PURE__ */ new Set(["exists", "type", "equals", "oneOf"]);
+var CONTRACT_ARGUMENT_OCCURRENCES = /* @__PURE__ */ new Set(["first", "last", "any", "all"]);
+var CONTRACT_ARGUMENT_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "array",
+  "null"
+]);
+var CONTRACT_ORDER_MODES = /* @__PURE__ */ new Set([
+  "first-occurrence",
+  "happens-before",
+  "all-occurrences"
+]);
+var CONTRACT_FAIL_ON = /* @__PURE__ */ new Set(["failed", "unknown", "skipped"]);
+var CONTRACT_SIDE_EFFECT_CLASSES = /* @__PURE__ */ new Set(["read", "write"]);
+var CONTRACT_MAX_STRING_LIST = 64;
+var CONTRACT_MAX_ARGUMENTS = 32;
+var CONTRACT_MAX_ORDER_RULES = 32;
+var CONTRACT_MAX_ANY_OF = 16;
+var CONTRACT_MAX_OPERATIONS = 32;
+var CONTRACT_MAX_REQUIRED_STAGES = 16;
+var CONTRACT_MAX_ONE_OF = 32;
 var RUN_KEYS = /* @__PURE__ */ new Set(["expected", "allowIncomplete", "maxDurationMs", "maxDepth"]);
 var TOOL_KEYS = /* @__PURE__ */ new Set(["required", "forbidden", "allowed", "minCount", "maxCount"]);
 var LLM_KEYS = /* @__PURE__ */ new Set([
@@ -20826,7 +23146,50 @@ function requireBoolean(value, pathPrefix) {
   if (typeof value !== "boolean") {
     throw new CheckConfigError(
       "AI_CHECK_CONFIG_INVALID_VALUE",
-      `${pathPrefix} must be a boolean.`
+      `${pathPrefix} must be a boolean.`
+    );
+  }
+  return value;
+}
+function requireNonEmptyString(value, pathPrefix) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new CheckConfigError(
+      "AI_CHECK_CONFIG_INVALID_VALUE",
+      `${pathPrefix} must be a non-empty string.`
+    );
+  }
+  return value;
+}
+function requireBoundedArray(value, pathPrefix, max) {
+  if (!Array.isArray(value)) {
+    throw new CheckConfigError(
+      "AI_CHECK_CONFIG_INVALID_VALUE",
+      `${pathPrefix} must be an array.`
+    );
+  }
+  if (value.length > max) {
+    throw new CheckConfigError(
+      "AI_CHECK_CONFIG_INVALID_VALUE",
+      `${pathPrefix} exceeds bound of ${max} items.`
+    );
+  }
+  return value;
+}
+function requireBoundedStringArray(value, pathPrefix, max = CONTRACT_MAX_STRING_LIST) {
+  const items = requireBoundedArray(value, pathPrefix, max);
+  if (items.some((item) => typeof item !== "string" || item.trim() === "")) {
+    throw new CheckConfigError(
+      "AI_CHECK_CONFIG_INVALID_VALUE",
+      `${pathPrefix} must be an array of non-empty strings.`
+    );
+  }
+  return items;
+}
+function requireOrderMode(value, pathPrefix) {
+  if (typeof value !== "string" || !CONTRACT_ORDER_MODES.has(value)) {
+    throw new CheckConfigError(
+      "AI_CHECK_CONFIG_INVALID_VALUE",
+      `${pathPrefix} must be one of: "first-occurrence", "happens-before", "all-occurrences".`
     );
   }
   return value;
@@ -20963,6 +23326,7 @@ function sectionHasEffect(section) {
   return Object.keys(section).length > 0;
 }
 function checkConfigHasEffect(config) {
+  if (contractConfigHasEffect(config.contract)) return true;
   const checks2 = config.checks;
   if (checks2 === void 0) return false;
   if ((checks2.select?.length ?? 0) > 0) return true;
@@ -20973,43 +23337,587 @@ function checkConfigHasEffect(config) {
   if (sectionHasEffect(checks2.safety)) return true;
   return false;
 }
+function contractConfigHasEffect(contract) {
+  if (contract === void 0) return false;
+  if (sectionHasEffect(contract.run)) return true;
+  if (sectionHasEffect(contract.tools)) return true;
+  if (sectionHasEffect(contract.llm)) return true;
+  if (sectionHasEffect(contract.observations)) {
+    return true;
+  }
+  if (sectionHasEffect(contract.controls)) return true;
+  if (sectionHasEffect(contract.retry)) return true;
+  if ((contract.alternatives?.anyOf?.length ?? 0) > 0) return true;
+  return false;
+}
+function parseContractRunSection(value, pathPrefix = "contract.run") {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_RUN_KEYS, pathPrefix);
+  const out = {};
+  if (record.requireCompleted !== void 0) {
+    out.requireCompleted = requireBoolean(
+      record.requireCompleted,
+      `${pathPrefix}.requireCompleted`
+    );
+  }
+  if (record.allowedStatuses !== void 0) {
+    out.allowedStatuses = requireBoundedStringArray(
+      record.allowedStatuses,
+      `${pathPrefix}.allowedStatuses`
+    );
+  }
+  if (record.maxDurationMs !== void 0) {
+    out.maxDurationMs = requireNonNegativeNumber(
+      record.maxDurationMs,
+      `${pathPrefix}.maxDurationMs`
+    );
+  }
+  return out;
+}
+function parseToolArgumentCheck(value, pathPrefix) {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_ARGUMENT_KEYS, pathPrefix);
+  const tool = requireNonEmptyString(record.tool, `${pathPrefix}.tool`);
+  if (typeof record.path !== "string") {
+    throw new CheckConfigError(
+      "AI_CHECK_CONFIG_INVALID_VALUE",
+      `${pathPrefix}.path must be a string JSON Pointer ("" or start with "/").`
+    );
+  }
+  const pathValue = record.path;
+  if (typeof record.operator !== "string" || !CONTRACT_ARGUMENT_OPERATORS.has(record.operator)) {
+    throw new CheckConfigError(
+      "AI_CHECK_CONFIG_INVALID_VALUE",
+      `${pathPrefix}.operator must be one of: "exists", "type", "equals", "oneOf".`
+    );
+  }
+  const operator = record.operator;
+  const out = { tool, path: pathValue, operator };
+  if (record.occurrence !== void 0) {
+    if (typeof record.occurrence !== "string" || !CONTRACT_ARGUMENT_OCCURRENCES.has(record.occurrence)) {
+      throw new CheckConfigError(
+        "AI_CHECK_CONFIG_INVALID_VALUE",
+        `${pathPrefix}.occurrence must be one of: "first", "last", "any", "all".`
+      );
+    }
+    out.occurrence = record.occurrence;
+  }
+  if (record.expected !== void 0) {
+    out.expected = record.expected;
+  }
+  if (record.oneOf !== void 0) {
+    out.oneOf = requireBoundedArray(record.oneOf, `${pathPrefix}.oneOf`, CONTRACT_MAX_ONE_OF);
+  }
+  if (record.type !== void 0) {
+    if (typeof record.type !== "string" || !CONTRACT_ARGUMENT_TYPES.has(record.type)) {
+      throw new CheckConfigError(
+        "AI_CHECK_CONFIG_INVALID_VALUE",
+        `${pathPrefix}.type must be one of: "string", "number", "boolean", "object", "array", "null".`
+      );
+    }
+    out.type = record.type;
+  }
+  return out;
+}
+function parseOrderRule(value, pathPrefix) {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_ORDER_RULE_KEYS, pathPrefix);
+  const out = {
+    before: requireNonEmptyString(record.before, `${pathPrefix}.before`),
+    after: requireNonEmptyString(record.after, `${pathPrefix}.after`)
+  };
+  if (record.occurrenceMode !== void 0) {
+    out.occurrenceMode = requireOrderMode(record.occurrenceMode, `${pathPrefix}.occurrenceMode`);
+  }
+  if (record.requireEndpoints !== void 0) {
+    out.requireEndpoints = requireBoolean(
+      record.requireEndpoints,
+      `${pathPrefix}.requireEndpoints`
+    );
+  }
+  return out;
+}
+function parseContractToolsSection(value, pathPrefix = "contract.tools") {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_TOOLS_KEYS, pathPrefix);
+  const out = {};
+  if (record.required !== void 0) {
+    out.required = requireBoundedStringArray(record.required, `${pathPrefix}.required`);
+  }
+  if (record.requiredTools !== void 0) {
+    out.requiredTools = requireBoundedStringArray(
+      record.requiredTools,
+      `${pathPrefix}.requiredTools`
+    );
+  }
+  if (record.forbidden !== void 0) {
+    out.forbidden = requireBoundedStringArray(record.forbidden, `${pathPrefix}.forbidden`);
+  }
+  if (record.forbiddenTools !== void 0) {
+    out.forbiddenTools = requireBoundedStringArray(
+      record.forbiddenTools,
+      `${pathPrefix}.forbiddenTools`
+    );
+  }
+  if (record.allowed !== void 0) {
+    out.allowed = requireBoundedStringArray(record.allowed, `${pathPrefix}.allowed`);
+  }
+  if (record.maxCalls !== void 0) {
+    out.maxCalls = requireNonNegativeNumber(record.maxCalls, `${pathPrefix}.maxCalls`);
+  }
+  if (record.requiredOrder !== void 0) {
+    out.requiredOrder = requireBoundedStringArray(
+      record.requiredOrder,
+      `${pathPrefix}.requiredOrder`
+    );
+  }
+  if (record.requiredOrderMode !== void 0) {
+    out.requiredOrderMode = requireOrderMode(
+      record.requiredOrderMode,
+      `${pathPrefix}.requiredOrderMode`
+    );
+  }
+  if (record.defaultOccurrenceMode !== void 0) {
+    out.defaultOccurrenceMode = requireOrderMode(
+      record.defaultOccurrenceMode,
+      `${pathPrefix}.defaultOccurrenceMode`
+    );
+  }
+  if (record.arguments !== void 0) {
+    const items = requireBoundedArray(
+      record.arguments,
+      `${pathPrefix}.arguments`,
+      CONTRACT_MAX_ARGUMENTS
+    );
+    out.arguments = items.map(
+      (item, index) => parseToolArgumentCheck(item, `${pathPrefix}.arguments[${index}]`)
+    );
+  }
+  if (record.orderRules !== void 0) {
+    const items = requireBoundedArray(
+      record.orderRules,
+      `${pathPrefix}.orderRules`,
+      CONTRACT_MAX_ORDER_RULES
+    );
+    out.orderRules = items.map(
+      (item, index) => parseOrderRule(item, `${pathPrefix}.orderRules[${index}]`)
+    );
+  }
+  return out;
+}
+function parseContractLlmSection(value, pathPrefix = "contract.llm") {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_LLM_KEYS, pathPrefix);
+  const out = {};
+  if (record.maxCalls !== void 0) {
+    out.maxCalls = requireNonNegativeNumber(record.maxCalls, `${pathPrefix}.maxCalls`);
+  }
+  if (record.maxTotalTokens !== void 0) {
+    out.maxTotalTokens = requireNonNegativeNumber(
+      record.maxTotalTokens,
+      `${pathPrefix}.maxTotalTokens`
+    );
+  }
+  if (record.allowedModels !== void 0) {
+    out.allowedModels = requireBoundedStringArray(
+      record.allowedModels,
+      `${pathPrefix}.allowedModels`
+    );
+  }
+  return out;
+}
+function parseRequireProvenance(value, pathPrefix) {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_PROVENANCE_KEYS, pathPrefix);
+  const out = {};
+  if (record.method !== void 0) {
+    out.method = requireBoolean(record.method, `${pathPrefix}.method`);
+  }
+  if (record.evidence !== void 0) {
+    out.evidence = requireBoolean(record.evidence, `${pathPrefix}.evidence`);
+  }
+  if (record.sameRunEventReference !== void 0) {
+    out.sameRunEventReference = requireBoolean(
+      record.sameRunEventReference,
+      `${pathPrefix}.sameRunEventReference`
+    );
+  }
+  return out;
+}
+function parseContractObservationsSection(value, pathPrefix = "contract.observations") {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_OBSERVATION_KEYS, pathPrefix);
+  const out = {};
+  if (record.required !== void 0) {
+    out.required = requireBoundedStringArray(record.required, `${pathPrefix}.required`);
+  }
+  if (record.failOn !== void 0) {
+    const items = requireBoundedArray(record.failOn, `${pathPrefix}.failOn`, CONTRACT_MAX_STRING_LIST);
+    for (const item of items) {
+      if (typeof item !== "string" || !CONTRACT_FAIL_ON.has(item)) {
+        throw new CheckConfigError(
+          "AI_CHECK_CONFIG_INVALID_VALUE",
+          `${pathPrefix}.failOn values must be "failed", "unknown", or "skipped".`
+        );
+      }
+    }
+    out.failOn = items;
+  }
+  if (record.requireProvenance !== void 0) {
+    out.requireProvenance = parseRequireProvenance(
+      record.requireProvenance,
+      `${pathPrefix}.requireProvenance`
+    );
+  }
+  return out;
+}
+function parseControlRequiredStage(value, pathPrefix) {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_CONTROL_STAGE_KEYS, pathPrefix);
+  if (typeof record.stage !== "string" || !CONTRACT_CONTROL_STAGES.has(record.stage)) {
+    throw new CheckConfigError(
+      "AI_CHECK_CONFIG_INVALID_VALUE",
+      `${pathPrefix}.stage must be one of: declared, presented, validated, enforced, observed, accepted.`
+    );
+  }
+  const out = {
+    stage: record.stage
+  };
+  if (record.observation !== void 0) {
+    out.observation = requireNonEmptyString(record.observation, `${pathPrefix}.observation`);
+  }
+  return out;
+}
+function parseContractControlsSection(value, pathPrefix = "contract.controls") {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_CONTROLS_KEYS, pathPrefix);
+  const out = {};
+  if (record.declaredTools !== void 0) {
+    out.declaredTools = requireBoundedStringArray(
+      record.declaredTools,
+      `${pathPrefix}.declaredTools`
+    );
+  }
+  if (record.enforcedTools !== void 0) {
+    out.enforcedTools = requireBoundedStringArray(
+      record.enforcedTools,
+      `${pathPrefix}.enforcedTools`
+    );
+  }
+  if (record.declaredToolsAttribute !== void 0) {
+    out.declaredToolsAttribute = requireNonEmptyString(
+      record.declaredToolsAttribute,
+      `${pathPrefix}.declaredToolsAttribute`
+    );
+  }
+  if (record.enforcedToolsAttribute !== void 0) {
+    out.enforcedToolsAttribute = requireNonEmptyString(
+      record.enforcedToolsAttribute,
+      `${pathPrefix}.enforcedToolsAttribute`
+    );
+  }
+  if (record.requireDeclaredMatchesEnforced !== void 0) {
+    out.requireDeclaredMatchesEnforced = requireBoolean(
+      record.requireDeclaredMatchesEnforced,
+      `${pathPrefix}.requireDeclaredMatchesEnforced`
+    );
+  }
+  if (record.requireObservedWithinEnforced !== void 0) {
+    out.requireObservedWithinEnforced = requireBoolean(
+      record.requireObservedWithinEnforced,
+      `${pathPrefix}.requireObservedWithinEnforced`
+    );
+  }
+  if (record.requireObservedWithinDeclared !== void 0) {
+    out.requireObservedWithinDeclared = requireBoolean(
+      record.requireObservedWithinDeclared,
+      `${pathPrefix}.requireObservedWithinDeclared`
+    );
+  }
+  if (record.requiredStages !== void 0) {
+    const items = requireBoundedArray(
+      record.requiredStages,
+      `${pathPrefix}.requiredStages`,
+      CONTRACT_MAX_REQUIRED_STAGES
+    );
+    out.requiredStages = items.map(
+      (item, index) => parseControlRequiredStage(item, `${pathPrefix}.requiredStages[${index}]`)
+    );
+  }
+  return out;
+}
+function parseRecoveryOperation(value, pathPrefix) {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_OPERATION_KEYS, pathPrefix);
+  const out = {
+    tool: requireNonEmptyString(record.tool, `${pathPrefix}.tool`)
+  };
+  if (record.maxAttempts !== void 0) {
+    out.maxAttempts = requireNonNegativeNumber(record.maxAttempts, `${pathPrefix}.maxAttempts`);
+  }
+  if (record.retryableErrors !== void 0) {
+    const errors = requireObject(record.retryableErrors, `${pathPrefix}.retryableErrors`);
+    rejectUnknownKeys(errors, CONTRACT_RETRYABLE_ERRORS_KEYS, `${pathPrefix}.retryableErrors`);
+    const retryableErrors = {};
+    if (errors.codes !== void 0) {
+      retryableErrors.codes = requireBoundedStringArray(
+        errors.codes,
+        `${pathPrefix}.retryableErrors.codes`
+      );
+    }
+    out.retryableErrors = retryableErrors;
+  }
+  if (record.requireFailureBeforeRetry !== void 0) {
+    out.requireFailureBeforeRetry = requireBoolean(
+      record.requireFailureBeforeRetry,
+      `${pathPrefix}.requireFailureBeforeRetry`
+    );
+  }
+  if (record.requireSameArguments !== void 0) {
+    if (record.requireSameArguments === true || record.requireSameArguments === false) {
+      out.requireSameArguments = record.requireSameArguments;
+    } else if (record.requireSameArguments === "structured-or-digest") {
+      out.requireSameArguments = "structured-or-digest";
+    } else {
+      throw new CheckConfigError(
+        "AI_CHECK_CONFIG_INVALID_VALUE",
+        `${pathPrefix}.requireSameArguments must be a boolean or "structured-or-digest".`
+      );
+    }
+  }
+  if (record.requireTerminalSuccess !== void 0) {
+    out.requireTerminalSuccess = requireBoolean(
+      record.requireTerminalSuccess,
+      `${pathPrefix}.requireTerminalSuccess`
+    );
+  }
+  if (record.requireRecoveredFailureVisible !== void 0) {
+    out.requireRecoveredFailureVisible = requireBoolean(
+      record.requireRecoveredFailureVisible,
+      `${pathPrefix}.requireRecoveredFailureVisible`
+    );
+  }
+  if (record.successfulResultDependency !== void 0) {
+    const dep = requireObject(
+      record.successfulResultDependency,
+      `${pathPrefix}.successfulResultDependency`
+    );
+    rejectUnknownKeys(dep, CONTRACT_RESULT_DEP_KEYS, `${pathPrefix}.successfulResultDependency`);
+    if (dep.consumerKind !== "LLM") {
+      throw new CheckConfigError(
+        "AI_CHECK_CONFIG_INVALID_VALUE",
+        `${pathPrefix}.successfulResultDependency.consumerKind must be "LLM".`
+      );
+    }
+    const dependency = { consumerKind: "LLM" };
+    if (dep.requireExplicitReference !== void 0) {
+      dependency.requireExplicitReference = requireBoolean(
+        dep.requireExplicitReference,
+        `${pathPrefix}.successfulResultDependency.requireExplicitReference`
+      );
+    }
+    out.successfulResultDependency = dependency;
+  }
+  if (record.sideEffectClass !== void 0) {
+    if (typeof record.sideEffectClass !== "string" || !CONTRACT_SIDE_EFFECT_CLASSES.has(record.sideEffectClass)) {
+      throw new CheckConfigError(
+        "AI_CHECK_CONFIG_INVALID_VALUE",
+        `${pathPrefix}.sideEffectClass must be "read" or "write".`
+      );
+    }
+    out.sideEffectClass = record.sideEffectClass;
+  }
+  return out;
+}
+function parseContractRetrySection(value, pathPrefix = "contract.retry") {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_RETRY_KEYS, pathPrefix);
+  const out = {};
+  if (record.maxAttempts !== void 0) {
+    out.maxAttempts = requireNonNegativeNumber(record.maxAttempts, `${pathPrefix}.maxAttempts`);
+  }
+  if (record.requireTerminalResult !== void 0) {
+    out.requireTerminalResult = requireBoolean(
+      record.requireTerminalResult,
+      `${pathPrefix}.requireTerminalResult`
+    );
+  }
+  if (record.fallbackOnlyAfterFailure !== void 0) {
+    out.fallbackOnlyAfterFailure = requireBoolean(
+      record.fallbackOnlyAfterFailure,
+      `${pathPrefix}.fallbackOnlyAfterFailure`
+    );
+  }
+  if (record.nonIdempotentTools !== void 0) {
+    out.nonIdempotentTools = requireBoundedStringArray(
+      record.nonIdempotentTools,
+      `${pathPrefix}.nonIdempotentTools`
+    );
+  }
+  if (record.requireIdempotencyEvidenceForRetry !== void 0) {
+    out.requireIdempotencyEvidenceForRetry = requireBoolean(
+      record.requireIdempotencyEvidenceForRetry,
+      `${pathPrefix}.requireIdempotencyEvidenceForRetry`
+    );
+  }
+  if (record.requireRecoveredFailureVisible !== void 0) {
+    out.requireRecoveredFailureVisible = requireBoolean(
+      record.requireRecoveredFailureVisible,
+      `${pathPrefix}.requireRecoveredFailureVisible`
+    );
+  }
+  if (record.operations !== void 0) {
+    const items = requireBoundedArray(
+      record.operations,
+      `${pathPrefix}.operations`,
+      CONTRACT_MAX_OPERATIONS
+    );
+    out.operations = items.map(
+      (item, index) => parseRecoveryOperation(item, `${pathPrefix}.operations[${index}]`)
+    );
+  }
+  return out;
+}
+function parseContractScopeSection(value) {
+  const record = requireObject(value, "contract.scope");
+  rejectUnknownKeys(record, CONTRACT_SCOPE_KEYS, "contract.scope");
+  const out = {};
+  if (record.runId !== void 0) {
+    out.runId = requireNonEmptyString(record.runId, "contract.scope.runId");
+  }
+  if (record.subAgentId !== void 0) {
+    out.subAgentId = requireNonEmptyString(record.subAgentId, "contract.scope.subAgentId");
+  }
+  if (record.groupId !== void 0) {
+    out.groupId = requireNonEmptyString(record.groupId, "contract.scope.groupId");
+  }
+  if (record.workflowStep !== void 0) {
+    out.workflowStep = requireNonEmptyString(
+      record.workflowStep,
+      "contract.scope.workflowStep"
+    );
+  }
+  if (record.rootEventId !== void 0) {
+    out.rootEventId = requireNonEmptyString(record.rootEventId, "contract.scope.rootEventId");
+  }
+  return out;
+}
+function parseContractBodySection(value, pathPrefix) {
+  const record = requireObject(value, pathPrefix);
+  rejectUnknownKeys(record, CONTRACT_BODY_KEYS, pathPrefix);
+  const out = {};
+  if (record.run !== void 0) out.run = parseContractRunSection(record.run, `${pathPrefix}.run`);
+  if (record.tools !== void 0) {
+    out.tools = parseContractToolsSection(record.tools, `${pathPrefix}.tools`);
+  }
+  if (record.llm !== void 0) out.llm = parseContractLlmSection(record.llm, `${pathPrefix}.llm`);
+  if (record.observations !== void 0) {
+    out.observations = parseContractObservationsSection(
+      record.observations,
+      `${pathPrefix}.observations`
+    );
+  }
+  if (record.controls !== void 0) {
+    out.controls = parseContractControlsSection(record.controls, `${pathPrefix}.controls`);
+  }
+  if (record.retry !== void 0) {
+    out.retry = parseContractRetrySection(record.retry, `${pathPrefix}.retry`);
+  }
+  return out;
+}
+function parseContractAlternativesSection(value) {
+  const record = requireObject(value, "contract.alternatives");
+  rejectUnknownKeys(record, CONTRACT_ALT_KEYS, "contract.alternatives");
+  if (record.anyOf === void 0) {
+    throw new CheckConfigError(
+      "AI_CHECK_CONFIG_INVALID_VALUE",
+      "contract.alternatives.anyOf is required."
+    );
+  }
+  const items = requireBoundedArray(
+    record.anyOf,
+    "contract.alternatives.anyOf",
+    CONTRACT_MAX_ANY_OF
+  );
+  const anyOf = items.map((item, index) => {
+    const pathPrefix = `contract.alternatives.anyOf[${index}]`;
+    const branch = requireObject(item, pathPrefix);
+    rejectUnknownKeys(branch, CONTRACT_ALT_BRANCH_KEYS, pathPrefix);
+    const id = requireNonEmptyString(branch.id, `${pathPrefix}.id`);
+    if (branch.contract === void 0) {
+      throw new CheckConfigError(
+        "AI_CHECK_CONFIG_INVALID_VALUE",
+        `${pathPrefix}.contract is required.`
+      );
+    }
+    const out = {
+      id,
+      contract: parseContractBodySection(branch.contract, `${pathPrefix}.contract`)
+    };
+    if (branch.description !== void 0) {
+      out.description = requireNonEmptyString(branch.description, `${pathPrefix}.description`);
+    }
+    return out;
+  });
+  return { anyOf };
+}
+function parseContractSection(value) {
+  const record = requireObject(value, "contract");
+  rejectUnknownKeys(record, CONTRACT_KEYS, "contract");
+  const bodyOnly = {};
+  for (const key of Object.keys(record)) {
+    if (CONTRACT_BODY_KEYS.has(key)) bodyOnly[key] = record[key];
+  }
+  const out = { ...parseContractBodySection(bodyOnly, "contract") };
+  if (record.scope !== void 0) out.scope = parseContractScopeSection(record.scope);
+  if (record.alternatives !== void 0) {
+    out.alternatives = parseContractAlternativesSection(record.alternatives);
+  }
+  return out;
+}
 function parseCheckConfig(value) {
   if (value === void 0 || value === null) return {};
   if (typeof value !== "object" || Array.isArray(value)) {
     throw new CheckConfigError("AI_CHECK_CONFIG_INVALID_VALUE", "Config must export an object.");
   }
   const root = value;
-  if ("contract" in root) {
-    throw new CheckConfigError(
-      "AI_CHECK_CONFIG_UNKNOWN_KEY",
-      'Top-level "contract" is not supported by `agent-inspect check --config`. Use the TraceContract TypeScript API (`defineTraceContract` / `evaluateTraceContract` from `agent-inspect/checks`), or express tool/run/llm rules under `checks`.'
-    );
-  }
   const rootKeys = Object.keys(root);
   for (const key of rootKeys) {
-    if (key === "checks") continue;
-    const suggestion = closestKey(key, ["checks"]);
+    if (ROOT_CONFIG_KEYS.has(key)) continue;
+    const suggestion = closestKey(key, [...ROOT_CONFIG_KEYS]);
     const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
     throw new CheckConfigError(
       "AI_CHECK_CONFIG_UNKNOWN_KEY",
-      `Unknown top-level check config key "${key}". Allowed: checks.${hint}`
+      `Unknown top-level check config key "${key}". Allowed: checks, contract.${hint}`
     );
   }
-  if (!("checks" in root)) return {};
-  const checksRecord = requireObject(root.checks, "checks");
-  rejectUnknownKeys(checksRecord, CHECKS_KEYS, "checks");
-  const checks2 = {};
-  if (checksRecord.select !== void 0) {
-    checks2.select = requireStringArray(checksRecord.select, "checks.select");
+  const out = {};
+  if ("checks" in root) {
+    const checksRecord = requireObject(root.checks, "checks");
+    rejectUnknownKeys(checksRecord, CHECKS_KEYS, "checks");
+    const checks2 = {};
+    if (checksRecord.select !== void 0) {
+      checks2.select = requireStringArray(checksRecord.select, "checks.select");
+    }
+    if (checksRecord.run !== void 0) checks2.run = parseRunSection(checksRecord.run);
+    if (checksRecord.tool !== void 0) checks2.tool = parseToolSection(checksRecord.tool);
+    if (checksRecord.llm !== void 0) checks2.llm = parseLlmSection(checksRecord.llm);
+    if (checksRecord.structure !== void 0) {
+      checks2.structure = parseStructureSection(checksRecord.structure);
+    }
+    if (checksRecord.safety !== void 0) checks2.safety = parseSafetySection(checksRecord.safety);
+    out.checks = checks2;
+  }
+  if ("contract" in root) {
+    out.contract = parseContractSection(root.contract);
   }
-  if (checksRecord.run !== void 0) checks2.run = parseRunSection(checksRecord.run);
-  if (checksRecord.tool !== void 0) checks2.tool = parseToolSection(checksRecord.tool);
-  if (checksRecord.llm !== void 0) checks2.llm = parseLlmSection(checksRecord.llm);
-  if (checksRecord.structure !== void 0) {
-    checks2.structure = parseStructureSection(checksRecord.structure);
+  if (out.contract !== void 0 && contractConfigHasEffect(out.contract) && checkConfigHasEffect({ checks: out.checks })) {
+    throw new CheckConfigError(
+      "AI_CHECK_CONFIG_INVALID_VALUE",
+      'Config cannot combine top-level "checks" and "contract". Use one vocabulary per config file.'
+    );
   }
-  if (checksRecord.safety !== void 0) checks2.safety = parseSafetySection(checksRecord.safety);
-  return { checks: checks2 };
+  return out;
 }
 async function loadConfig(configPath) {
   if (configPath === void 0) return {};
@@ -21133,7 +24041,7 @@ function buildRules(config, options, presetSelect = []) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       diagnostics.push(
-        diagnostic5("AI_CHECK_INVALID_ARGUMENTS", `--max-step-duration: ${message}`)
+        diagnostic6("AI_CHECK_INVALID_ARGUMENTS", `--max-step-duration: ${message}`)
       );
     }
   }
@@ -21168,7 +24076,7 @@ function buildRules(config, options, presetSelect = []) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       diagnostics.push(
-        diagnostic5("AI_CHECK_INVALID_ARGUMENTS", `--fail-on-observation: ${message}`)
+        diagnostic6("AI_CHECK_INVALID_ARGUMENTS", `--fail-on-observation: ${message}`)
       );
     }
   }
@@ -21310,8 +24218,8 @@ function printHuman2(result, options = {}) {
     `Summary: ${result.summary.failed} failed, ${result.summary.warnings} warning(s), ${result.summary.errors} error(s)`
   );
   console.log(`Rules evaluated: ${result.summary.rulesEvaluated ?? result.ruleExecutions?.length ?? 0}`);
-  for (const diagnostic7 of result.diagnostics) {
-    console.log(`- ${diagnostic7.code}: ${diagnostic7.message}`);
+  for (const diagnostic8 of result.diagnostics) {
+    console.log(`- ${diagnostic8.code}: ${diagnostic8.message}`);
   }
   for (const finding of result.findings) {
     const path44 = finding.evidence[0]?.path;
@@ -21337,6 +24245,7 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
   let evidenceRead;
   let evidenceRunIds = [];
   let evidenceSourceContents;
+  let evidenceContract;
   const sessionId = options.session?.trim();
   const groupId = options.group?.trim();
   const useSessionScope = Boolean(sessionId || groupId);
@@ -21345,7 +24254,7 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
     if (options.config !== void 0 && !checkConfigHasEffect(config)) {
       result = errorResult2(
         "AI_CHECK_CONFIG_NO_EFFECTIVE_RULES",
-        "Explicit --config has no effective check rules. Configure checks.select, checks.run, checks.tool, checks.llm, checks.structure, or checks.safety."
+        "Explicit --config has no effective check rules. Configure checks.select, checks.run, checks.tool, checks.llm, checks.structure, checks.safety, or contract."
       );
       if (options.json) printJson2(result);
       else printHuman2(result, options);
@@ -21353,7 +24262,11 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
       return;
     }
     let effectiveOptions = options;
-    const resolved = resolvePreset(options.preset, {
+    const useContract = config.contract !== void 0 && contractConfigHasEffect(config.contract);
+    if (useContract) {
+      evidenceContract = defineTraceContract(config.contract);
+    }
+    const resolved = useContract ? void 0 : resolvePreset(options.preset, {
       hasToolRules: hasToolRulesConfigured(config, options)
     });
     if (resolved !== void 0) {
@@ -21361,7 +24274,7 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
       config = applied.config;
       effectiveOptions = applied.options;
     }
-    const built = buildRules(config, effectiveOptions, resolved?.select ?? []);
+    const built = useContract ? { rules: [], select: [], diagnostics: [] } : buildRules(config, effectiveOptions, resolved?.select ?? []);
     if (built.diagnostics.some((item) => item.severity === "error")) {
       result = errorResult2("AI_CHECK_INVALID_CONFIG", "Invalid check configuration.");
       result.diagnostics = [...built.diagnostics];
@@ -21383,6 +24296,7 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
       });
       const perRun = [];
       const sourceContents = /* @__PURE__ */ new Map();
+      const definedContract = evidenceContract;
       for (const meta2 of scoped.metas) {
         const read = await openTrace(
           { type: "file", path: meta2.filePath },
@@ -21399,23 +24313,20 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
 `
           );
         }
+        const base = definedContract ? evaluateTraceContract({ read }, definedContract, { runId: meta2.runId }) : runTraceChecks(
+          { read },
+          {
+            rules: built.rules,
+            select: built.select,
+            runId: meta2.runId
+          }
+        );
         perRun.push(
-          mergeSafetyExtensions(
-            runTraceChecks(
-              { read },
-              {
-                rules: built.rules,
-                select: built.select,
-                runId: meta2.runId
-              }
-            ),
-            read,
-            {
-              ...options.guardrails ? { guardrails: options.guardrails } : {},
-              ...options.circuit ? { circuits: options.circuit } : {},
-              runId: meta2.runId
-            }
-          )
+          mergeSafetyExtensions(base, read, {
+            ...options.guardrails ? { guardrails: options.guardrails } : {},
+            ...options.circuit ? { circuits: options.circuit } : {},
+            runId: meta2.runId
+          })
         );
       }
       evidenceRunIds = scoped.runIds;
@@ -21454,22 +24365,25 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
           ])
         );
       }
-      result = mergeSafetyExtensions(
-        runTraceChecks(
-          { read },
-          {
-            rules: built.rules,
-            select: built.select,
-            ...options.run !== void 0 ? { runId: options.run } : {}
-          }
-        ),
-        read,
+      const base = useContract && evidenceContract !== void 0 ? evaluateTraceContract(
+        { read },
+        evidenceContract,
+        {
+          ...options.run !== void 0 ? { runId: options.run } : {}
+        }
+      ) : runTraceChecks(
+        { read },
         {
-          ...options.guardrails ? { guardrails: options.guardrails } : {},
-          ...options.circuit ? { circuits: options.circuit } : {},
+          rules: built.rules,
+          select: built.select,
           ...options.run !== void 0 ? { runId: options.run } : {}
         }
       );
+      result = mergeSafetyExtensions(base, read, {
+        ...options.guardrails ? { guardrails: options.guardrails } : {},
+        ...options.circuit ? { circuits: options.circuit } : {},
+        ...options.run !== void 0 ? { runId: options.run } : {}
+      });
     }
   } catch (error) {
     if (phase === "config") {
@@ -21513,7 +24427,15 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
         checkResultsJson: checkResultToEvidenceJson(result, runIds),
         summaryText: `Check status: ${result.status}`,
         redactionProfile,
-        format: evidenceFormat
+        format: evidenceFormat,
+        ...evidenceContract !== void 0 ? {
+          contractPackage: {
+            engineVersion: "",
+            source: "file",
+            contract: evidenceContract,
+            ...options.config !== void 0 ? { path: options.config } : {}
+          }
+        } : {}
       });
       if (!options.json) {
         console.log(`Evidence: ${written}`);
@@ -22829,7 +25751,7 @@ function evidenceForEvent(event, path44) {
     }
   ];
 }
-function fail2(ruleId, message, evidence, expected, actual) {
+function fail5(ruleId, message, evidence, expected, actual) {
   return {
     ruleId,
     status: "fail",
@@ -23025,7 +25947,7 @@ var checks = {
       "eval.requireSuccess",
       "run",
       (context) => context.run.status === "ok" ? [] : [
-        fail2(
+        fail5(
           "eval.requireSuccess",
           "Run did not complete successfully.",
           evidenceForRun(context.run, "status"),
@@ -23040,7 +25962,7 @@ var checks = {
     return createRule("eval.requiredTools", "tool", (context) => {
       const tools = new Set(nodeNames(context.nodes, "TOOL"));
       return expected.filter((name) => !tools.has(name)).map(
-        (name) => fail2(
+        (name) => fail5(
           "eval.requiredTools",
           `Required tool ${name} did not appear.`,
           evidenceForRun(context.run, "children"),
@@ -23056,7 +25978,7 @@ var checks = {
       "eval.forbiddenTools",
       "tool",
       (context) => context.nodes.filter((node) => node.event.kind === "TOOL" && blocked.includes(node.event.name)).map(
-        (node) => fail2(
+        (node) => fail5(
           "eval.forbiddenTools",
           `Forbidden tool ${node.event.name} appeared.`,
           evidenceForEvent(node.event, "name"),
@@ -23071,7 +25993,7 @@ var checks = {
       "eval.maxDurationMs",
       "run",
       (context) => context.run.durationMs !== void 0 && context.run.durationMs > maxDurationMs ? [
-        fail2(
+        fail5(
           "eval.maxDurationMs",
           `Run duration exceeded ${maxDurationMs}ms.`,
           evidenceForRun(context.run, "durationMs"),
@@ -23088,7 +26010,7 @@ var checks = {
         void 0
       );
       return deepest !== void 0 && deepest.depth > maxDepth ? [
-        fail2(
+        fail5(
           "eval.maxDepth",
           `Run tree depth exceeded ${maxDepth}.`,
           evidenceForEvent(deepest.event, "depth"),
@@ -23105,7 +26027,7 @@ var checks = {
       (context) => context.nodes.flatMap((node) => {
         const retries = numericAttribute(node, ["retryCount", "retries", "attempt"]);
         return retries !== void 0 && retries > maxRetries ? [
-          fail2(
+          fail5(
             "eval.maxRetries",
             `Retry count exceeded ${maxRetries}.`,
             evidenceForEvent(node.event, "attributes.retryCount"),
@@ -23120,7 +26042,7 @@ var checks = {
     return createRule("eval.maxTotalTokens", "llm", (context) => {
       const total = totalTokenCount(context.events);
       return total > maxTotalTokens ? [
-        fail2(
+        fail5(
           "eval.maxTotalTokens",
           `Total token usage exceeded ${maxTotalTokens}.`,
           evidenceForRun(context.run, "tokenUsage.total"),
@@ -23135,7 +26057,7 @@ var checks = {
       "eval.noFailedSteps",
       "run",
       (context) => context.nodes.filter((node) => node.event.status === "error" || node.event.kind === "ERROR").map(
-        (node) => fail2(
+        (node) => fail5(
           "eval.noFailedSteps",
           "Run contains a failed step or error node.",
           evidenceForEvent(node.event, "status"),
@@ -23153,7 +26075,7 @@ var checks = {
         (node, index) => index < firstLlmIndex && node.event.kind === "RETRIEVER"
       );
       return retrievalIndex === -1 ? [
-        fail2(
+        fail5(
           "eval.requiredRetrievalBeforeGeneration",
           "No retrieval step appeared before the first LLM generation.",
           evidenceForEvent(context.nodes[firstLlmIndex].event, "kind"),
@@ -23169,7 +26091,7 @@ var checks = {
       const decisions = context.nodes.filter((node) => node.event.kind === "DECISION");
       if (decisions.length === 0) {
         return [
-          fail2(
+          fail5(
             "eval.requiredDecisionMetadata",
             "No decision node is available for required metadata.",
             evidenceForRun(context.run, "children"),
@@ -23180,7 +26102,7 @@ var checks = {
       }
       return decisions.flatMap(
         (node) => required.filter((key) => !hasAttribute(node, key)).map(
-          (key) => fail2(
+          (key) => fail5(
             "eval.requiredDecisionMetadata",
             `Decision metadata ${key} is missing.`,
             evidenceForEvent(node.event, `attributes.${key}`),
@@ -23201,7 +26123,7 @@ var checks = {
       const contexts = collectTextFields(context.nodes, contextKeys, ["RETRIEVER", "TOOL"]);
       if (answers.length === 0 || contexts.length === 0) {
         return [
-          fail2(
+          fail5(
             "eval.contextOverlap",
             "Answer and context text are required for overlap evaluation.",
             firstEvidence(answers.length > 0 ? answers : contexts, context.run, "children"),
@@ -23215,7 +26137,7 @@ var checks = {
       const sharedTerms = [...answerTerms].filter((term) => contextTerms.has(term)).length;
       const overlap = answerTerms.size === 0 ? 0 : sharedTerms / answerTerms.size;
       return sharedTerms < minSharedTerms || overlap < minOverlap ? [
-        fail2(
+        fail5(
           "eval.contextOverlap",
           "Answer text did not sufficiently overlap retrieved context.",
           firstEvidence(answers, context.run, "attributes.answer"),
@@ -23243,7 +26165,7 @@ var checks = {
       const quotes = quotedSnippets(answerText, minQuoteLength);
       if (quotes.length === 0) {
         return requireQuote ? [
-          fail2(
+          fail5(
             "eval.quoteOverlap",
             "Answer did not contain a quote for overlap evaluation.",
             firstEvidence(answers, context.run, "attributes.answer"),
@@ -23254,7 +26176,7 @@ var checks = {
       }
       const missing = quotes.filter((quote) => !contextText.includes(quote.toLowerCase()));
       return missing.length > 0 ? [
-        fail2(
+        fail5(
           "eval.quoteOverlap",
           "Quoted answer text did not appear in retrieved context.",
           firstEvidence(answers, context.run, "attributes.answer"),
@@ -23272,7 +26194,7 @@ var checks = {
       const citations = collectTextFields(context.nodes, citationKeys);
       const count = citationCount(answers.map((field) => field.text).join(" "), citations);
       return count === 0 ? [
-        fail2(
+        fail5(
           "eval.citationPresence",
           "Answer did not include citations or source references.",
           firstEvidence(answers, context.run, "attributes.answer"),
@@ -23290,7 +26212,7 @@ var checks = {
       const availableSet = new Set(available);
       const missing = expected.filter((id) => !availableSet.has(id));
       return missing.length > 0 ? [
-        fail2(
+        fail5(
           "eval.requiredSourceIds",
           "Required source IDs were not present in trace context or citations.",
           evidenceForRun(context.run, "children"),
@@ -23310,7 +26232,7 @@ var checks = {
       const tooShort = options.minCharacters !== void 0 && characters < options.minCharacters || options.minWords !== void 0 && words < options.minWords;
       const tooLong = options.maxCharacters !== void 0 && characters > options.maxCharacters || options.maxWords !== void 0 && words > options.maxWords;
       return answer.length === 0 || tooShort || tooLong ? [
-        fail2(
+        fail5(
           "eval.answerLengthBounds",
           "Answer length fell outside required bounds.",
           firstEvidence(answers, context.run, "attributes.answer"),
@@ -23333,7 +26255,7 @@ var checks = {
       const answer = answers.map((field) => field.text).join(" ").toLowerCase();
       const matches = banned.filter((phrase) => answer.includes(phrase));
       return matches.length > 0 ? [
-        fail2(
+        fail5(
           "eval.bannedUnsupportedPhrases",
           "Answer contained banned unsupported-answer phrasing.",
           firstEvidence(answers, context.run, "attributes.answer"),
@@ -23355,8 +26277,8 @@ function renderEvalMarkdown(result) {
   ];
   if (result.diagnostics.length > 0) {
     lines.push("", "## Diagnostics");
-    for (const diagnostic7 of result.diagnostics) {
-      lines.push(`- ${diagnostic7.code}: ${diagnostic7.message}`);
+    for (const diagnostic8 of result.diagnostics) {
+      lines.push(`- ${diagnostic8.code}: ${diagnostic8.message}`);
     }
   }
   if (result.findings.length > 0) {
@@ -23373,7 +26295,7 @@ function renderEvalMarkdown(result) {
 // packages/cli/src/eval.ts
 var CONFIG_EXTENSIONS3 = /* @__PURE__ */ new Set([".json", ".js", ".mjs", ".cjs"]);
 var TS_CONFIG_EXTENSIONS3 = /* @__PURE__ */ new Set([".ts", ".mts", ".cts"]);
-function diagnostic6(code, message, severity = "error") {
+function diagnostic7(code, message, severity = "error") {
   return { code, message, severity };
 }
 function errorResult4(code, message, format = "unknown") {
@@ -23383,7 +26305,7 @@ function errorResult4(code, message, format = "unknown") {
     format,
     summary: { passed: 0, failed: 0, warnings: 0, errors: 1 },
     findings: [],
-    diagnostics: [diagnostic6(code, message)]
+    diagnostics: [diagnostic7(code, message)]
   };
 }
 function parseNumber2(value, label) {
@@ -23552,8 +26474,8 @@ function printHuman3(result) {
   console.log(
     `Summary: ${result.summary.failed} failed, ${result.summary.warnings} warning(s), ${result.summary.errors} error(s)`
   );
-  for (const diagnostic7 of result.diagnostics) {
-    console.log(`- ${diagnostic7.code}: ${diagnostic7.message}`);
+  for (const diagnostic8 of result.diagnostics) {
+    console.log(`- ${diagnostic8.code}: ${diagnostic8.message}`);
   }
   for (const finding of result.findings) {
     const path44 = finding.evidence[0]?.path;
@@ -23676,8 +26598,8 @@ function renderCheckSection(result) {
     const path44 = finding.evidence[0]?.path ?? "(run)";
     lines.push(`- ${finding.ruleId}: ${finding.message} (${path44})`);
   }
-  for (const diagnostic7 of result.diagnostics.slice(0, 10)) {
-    lines.push(`- ${diagnostic7.code}: ${diagnostic7.message}`);
+  for (const diagnostic8 of result.diagnostics.slice(0, 10)) {
+    lines.push(`- ${diagnostic8.code}: ${diagnostic8.message}`);
   }
   return lines.join("\n");
 }
@@ -26232,7 +29154,7 @@ async function indexSqliteCleanCommand(options = {}) {
 function printJson4(payload) {
   console.log(JSON.stringify(payload, null, 2));
 }
-function fail3(json, message) {
+function fail6(json, message) {
   if (json) {
     printJson4({ ok: false, error: message });
   } else {
@@ -26283,14 +29205,14 @@ async function workspaceInitCommand(options = {}) {
     for (const dir of result.createdDirs) console.log(`Created ${dir}/`);
     console.log("\nNext: `agent-inspect workspace status`");
   } catch (error) {
-    fail3(options.json, error instanceof Error ? error.message : String(error));
+    fail6(options.json, error instanceof Error ? error.message : String(error));
   }
 }
 async function workspaceStatusCommand(options = {}) {
   const location = resolveWorkspaceLocation(options.cwd);
   const manifestResult = await readWorkspaceManifestFile(location);
   if (!manifestResult.ok || !manifestResult.manifest) {
-    fail3(
+    fail6(
       options.json,
       manifestResult.exists ? `invalid workspace.json: ${manifestResult.errors.join("; ")}` : "no workspace found (run `agent-inspect workspace init`)"
     );
@@ -26312,7 +29234,7 @@ async function workspaceStatusCommand(options = {}) {
       `Index:     ${status.index.enabled ? status.index.type : "disabled"}${status.index.exists ? " (present)" : ""}`
     );
   } catch (error) {
-    fail3(options.json, error instanceof Error ? error.message : String(error));
+    fail6(options.json, error instanceof Error ? error.message : String(error));
   }
 }
 async function workspaceDoctorCommand(options = {}) {
@@ -26334,7 +29256,7 @@ async function workspaceCleanCommand(options = {}) {
   const location = resolveWorkspaceLocation(options.cwd);
   const manifestResult = await readWorkspaceManifestFile(location);
   if (!manifestResult.ok || !manifestResult.manifest) {
-    fail3(
+    fail6(
       options.json,
       manifestResult.exists ? `invalid workspace.json: ${manifestResult.errors.join("; ")}` : "no workspace found (run `agent-inspect workspace init`)"
     );
@@ -26359,7 +29281,7 @@ async function workspaceCleanCommand(options = {}) {
     if (result.removed.length === 0) console.log("- (nothing)");
     for (const item of result.removed) console.log(`- ${item}`);
   } catch (error) {
-    fail3(options.json, error instanceof Error ? error.message : String(error));
+    fail6(options.json, error instanceof Error ? error.message : String(error));
   }
 }
 async function workspacePathCommand(options = {}) {