@agent-inspect/viewer 6.27.0 → 6.29.0

package/dist/index.mjs

@@ -165,6 +165,8 @@ function isPersistedTokenUsage(value) {
   if (!isOptionalNonNegativeNumber(value.output)) return false;
   if (!isOptionalNonNegativeNumber(value.total)) return false;
   if (!isOptionalNonNegativeNumber(value.cached)) return false;
+  if (!isOptionalNonNegativeNumber(value.cacheWrite)) return false;
+  if (!isOptionalNonNegativeNumber(value.reasoning)) return false;
   return true;
 }
 function isPersistedTraceContext(value) {
@@ -1587,1639 +1589,1639 @@ function buildSessionIndex(inputRuns, options = {}) {
   };
 }
 
-// packages/core/src/exporters/helpers.ts
-function sortKeysDeep(input) {
-  if (input === null || typeof input !== "object") return input;
-  if (Array.isArray(input)) return input.map(sortKeysDeep);
-  const o = input;
-  const out = {};
-  for (const k of Object.keys(o).sort()) {
-    out[k] = sortKeysDeep(o[k]);
+// packages/core/src/diagnostics/programmatic.ts
+var PROGRAMMATIC_DIAGNOSTIC_SPECS = Object.freeze({
+  AI_TRACE_INPUT_INVALID: {
+    code: "AI_TRACE_INPUT_INVALID",
+    summary: 'Expected { type: "file", path }, { type: "directory", path }, { type: "string", content }, { type: "buffer", content }, or { type: "stdin" }.',
+    remediation: "For a file path, use openTraceFile(path).",
+    relatedCodes: ["invalid_input"]
+  },
+  AI_TRACE_FORMAT_UNSUPPORTED: {
+    code: "AI_TRACE_FORMAT_UNSUPPORTED",
+    summary: "No trace reader could detect the input format.",
+    remediation: "Pass an AgentInspect JSONL file via openTraceFile, or set options.format to a registered reader.",
+    relatedCodes: ["unsupported_format"]
+  },
+  AI_TRACE_FORMAT_AMBIGUOUS: {
+    code: "AI_TRACE_FORMAT_AMBIGUOUS",
+    summary: "Multiple trace readers matched the input with equal confidence.",
+    remediation: "Set options.format explicitly to disambiguate the reader.",
+    relatedCodes: ["ambiguous_format"]
+  },
+  AI_TRACE_FACTS_INPUT_NOT_NORMALIZED: {
+    code: "AI_TRACE_FACTS_INPUT_NOT_NORMALIZED",
+    summary: "TraceFacts requires TraceReadResult or PersistedInspectEvent[].",
+    remediation: "Use openTraceFile() to normalize a JSONL trace first."
+  },
+  AI_TRACE_CONTRACT_RUN_SELECTION_REQUIRED: {
+    code: "AI_TRACE_CONTRACT_RUN_SELECTION_REQUIRED",
+    summary: "Multiple runs are available; select a run before executing checks.",
+    remediation: "Pass options.runId or TraceCheckInput.selectedRun.",
+    relatedCodes: ["AI_CHECK_RUN_SELECTION_REQUIRED"]
+  },
+  AI_TRACE_RELATIONSHIP_SELF_PARENT: {
+    code: "AI_TRACE_RELATIONSHIP_SELF_PARENT",
+    summary: "A parentId equals its own event/step id.",
+    remediation: "Reject at capture (AI_LANGGRAPH_SELF_PARENT_REJECTED) or drop via logical projection; do not invent replacement parents.",
+    relatedCodes: [
+      "AI_LANGGRAPH_SELF_PARENT_REJECTED",
+      "AI_LOGICAL_SELF_PARENT_REMOVED"
+    ]
+  },
+  AI_TRACE_RELATIONSHIP_CYCLE: {
+    code: "AI_TRACE_RELATIONSHIP_CYCLE",
+    summary: "Trace contains a parentId cycle.",
+    remediation: "Use visibility-first tree linking for legacy fixtures; prefer acyclic capture for new adapter output.",
+    relatedCodes: ["structure.cycle"]
   }
-  return out;
+});
+function formatProgrammaticDiagnostic(code, detail) {
+  const spec = PROGRAMMATIC_DIAGNOSTIC_SPECS[code];
+  const summary = detail?.trim() ? detail.trim() : spec.summary;
+  return `${code}: ${summary} Remediation: ${spec.remediation}`;
 }
-function stableJson(value, pretty) {
-  const sorted = sortKeysDeep(value);
-  return JSON.stringify(sorted);
+
+// packages/core/src/safety/sensitive-key.ts
+function normalizeSensitiveKey(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
 }
+new Set(
+  [
+    "tokens",
+    "max_tokens",
+    "min_tokens",
+    "ls_max_tokens",
+    "token_count",
+    "token_limit",
+    "token_budget",
+    "input_tokens",
+    "output_tokens",
+    "total_tokens",
+    "cached_tokens",
+    "prompt_tokens",
+    "completion_tokens"
+  ].map(normalizeSensitiveKey)
+);
 
-// packages/core/src/diff/comparable.ts
-function extractOutputPreview(meta) {
-  if (meta === void 0) return void 0;
-  if ("outputPreview" in meta) return meta.outputPreview;
-  if ("resultPreview" in meta) return meta.resultPreview;
+// packages/core/src/checks/logical-events.ts
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function legacyEvent(event) {
+  const value = event.attributes?.legacyEvent;
+  return typeof value === "string" ? value : void 0;
+}
+function stepIdOf(event) {
+  const value = event.attributes?.stepId;
+  if (typeof value === "string" && value.trim() !== "") return value;
   return void 0;
 }
-function mapStepStatus(s) {
-  if (s === void 0) return "running";
-  return s;
+function cloneEvent(event) {
+  return {
+    ...event,
+    ...event.attributes !== void 0 ? { attributes: { ...event.attributes } } : {},
+    ...event.error !== void 0 ? { error: { ...event.error } } : {},
+    ...event.tokenUsage !== void 0 ? { tokenUsage: { ...event.tokenUsage } } : {},
+    ...event.source !== void 0 ? { source: { ...event.source } } : {}
+  };
 }
-function manualTraceEventsToComparableRun(events) {
-  const started = events.find((e) => e.event === "run_started");
-  if (!started || started.event !== "run_started") {
-    throw new Error("Invalid trace: missing run_started");
-  }
-  const rs = started;
-  const runId = rs.runId;
-  const completedAll = events.filter((e) => e.event === "run_completed");
-  const lastCompleted = completedAll[completedAll.length - 1];
-  let runStatus;
-  if (lastCompleted === void 0) runStatus = "running";
-  else runStatus = lastCompleted.status;
-  const durationMs = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
-  const steps = /* @__PURE__ */ new Map();
-  let order = 0;
-  for (const e of events) {
-    if (e.event !== "step_started") continue;
-    const s = e;
-    const meta = s.metadata ? { ...s.metadata } : void 0;
-    steps.set(s.stepId, {
-      id: s.stepId,
-      parentId: s.parentId,
-      name: s.name,
-      type: s.type,
-      order: order++,
-      timestamp: s.timestamp,
-      metadata: meta
-    });
-  }
-  for (const e of events) {
-    if (e.event !== "step_completed") continue;
-    const acc = steps.get(e.stepId);
-    if (!acc) continue;
-    acc.status = e.status;
-    acc.durationMs = e.durationMs;
-    if (e.error?.message) acc.errorMsg = e.error.message;
-    const extra = e;
-    if (extra.metadata !== void 0 && typeof extra.metadata === "object") {
-      acc.metadata = { ...acc.metadata ?? {}, ...extra.metadata };
-    }
-  }
-  const nodes = /* @__PURE__ */ new Map();
-  for (const acc of steps.values()) {
-    let meta = acc.metadata ? { ...acc.metadata } : void 0;
-    if (acc.parentId !== void 0 && !steps.has(acc.parentId)) {
-      meta = { ...meta ?? {}, agent_inspect_diff_parent_missing: true };
-    }
-    const outputPreview = extractOutputPreview(meta);
-    if (meta !== void 0 && ("outputPreview" in meta || "resultPreview" in meta)) {
-      delete meta.outputPreview;
-      delete meta.resultPreview;
-    }
-    const sc = {
-      id: acc.id,
-      name: acc.name,
-      type: acc.type,
-      status: mapStepStatus(acc.status),
-      durationMs: acc.durationMs,
-      error: acc.errorMsg,
-      metadata: meta && Object.keys(meta).length > 0 ? meta : void 0,
-      outputPreview,
-      children: []
-    };
-    nodes.set(acc.id, sc);
-  }
-  const roots = [];
-  const sortByOrder = (a, b) => {
-    const oa = steps.get(a.id)?.order ?? 0;
-    const ob = steps.get(b.id)?.order ?? 0;
-    return oa - ob;
+function mergeAttributes(start, complete) {
+  const merged = {
+    ...isRecord5(complete.attributes) ? complete.attributes : {},
+    ...isRecord5(start.attributes) ? start.attributes : {}
   };
-  for (const acc of steps.values()) {
-    const node = nodes.get(acc.id);
-    if (acc.parentId !== void 0 && nodes.has(acc.parentId)) {
-      nodes.get(acc.parentId).children.push(node);
-    } else {
-      roots.push(node);
-    }
-  }
-  roots.sort(sortByOrder);
-  for (const n of nodes.values()) {
-    n.children.sort(sortByOrder);
+  merged.legacyEvent = start.attributes?.legacyEvent ?? complete.attributes?.legacyEvent;
+  merged.legacyCompleteEvent = complete.attributes?.legacyEvent;
+  if (complete.attributes?.errorStack !== void 0) {
+    merged.errorStack = complete.attributes.errorStack;
   }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function pairStartComplete(start, complete) {
+  const attributes = mergeAttributes(start, complete);
+  const paired = {
+    ...cloneEvent(start),
+    status: complete.status,
+    timestamp: complete.timestamp ?? start.timestamp,
+    ...complete.endedAt !== void 0 ? { endedAt: complete.endedAt } : {},
+    ...complete.durationMs !== void 0 ? { durationMs: complete.durationMs } : {},
+    ...complete.error !== void 0 ? { error: { ...complete.error } } : {},
+    ...complete.tokenUsage !== void 0 && start.tokenUsage === void 0 ? { tokenUsage: { ...complete.tokenUsage } } : {},
+    ...attributes !== void 0 ? { attributes } : {}
+  };
   return {
-    runId,
-    name: rs.name,
-    status: runStatus,
-    durationMs,
-    steps: roots
+    ...paired,
+    sourceEventIds: Object.freeze([start.eventId, complete.eventId]),
+    projection: {
+      paired: true,
+      absorbedEventIds: Object.freeze([complete.eventId]),
+      parentNormalized: false,
+      ...start.parentId !== void 0 ? { originalParentId: start.parentId } : {}
+    }
   };
 }
-
-// packages/core/src/diff/engine.ts
-var DEFAULT_THRESHOLD_MS = 0;
-function pathSeg(step, index) {
-  return { index, name: step.name, stepId: step.id };
-}
-function buildPath(segments) {
-  return { path: [...segments] };
-}
-function pairSteps(left, right) {
-  const usedRight = /* @__PURE__ */ new Set();
-  const pairs = [];
-  for (let i = 0; i < left.length; i++) {
-    const L = left[i];
-    let R = right.find((r) => !usedRight.has(r.id) && r.id === L.id);
-    if (R === void 0 && i < right.length && !usedRight.has(right[i].id)) {
-      const cand = right[i];
-      if (cand.name === L.name && (cand.type ?? "") === (L.type ?? "")) {
-        R = cand;
-      }
+function asLogical(event, extras) {
+  return {
+    ...cloneEvent(event),
+    sourceEventIds: Object.freeze([event.eventId]),
+    projection: {
+      paired: false,
+      absorbedEventIds: Object.freeze([]),
+      parentNormalized: extras?.parentNormalized === true,
+      ...{}
     }
-    if (R === void 0) {
-      R = right.find(
-        (r) => !usedRight.has(r.id) && r.name === L.name && (r.type ?? "") === (L.type ?? "")
-      );
+  };
+}
+function projectLogicalEvents(events) {
+  const diagnostics = [];
+  const byRun = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const list = byRun.get(event.runId) ?? [];
+    list.push(event);
+    byRun.set(event.runId, list);
+  }
+  const absorbedIds = /* @__PURE__ */ new Set();
+  const logicalByRawId = /* @__PURE__ */ new Map();
+  const stepIdToLogicalId = /* @__PURE__ */ new Map();
+  const logical = [];
+  const orderedRuns = [...byRun.keys()].sort((a, b) => a.localeCompare(b));
+  for (const runId of orderedRuns) {
+    const runEvents = byRun.get(runId) ?? [];
+    const starts = [];
+    const completes = [];
+    const others = [];
+    for (const event of runEvents) {
+      const legacy = legacyEvent(event);
+      if (legacy === "step_started" || legacy === "run_started" && event.status === "running") {
+        starts.push(event);
+      } else if (legacy === "step_completed" || legacy === "run_completed") {
+        completes.push(event);
+      } else {
+        others.push(event);
+      }
     }
-    if (R !== void 0) {
-      usedRight.add(R.id);
-      pairs.push([L, R]);
-    } else {
-      pairs.push([L, void 0]);
+    const usedCompletes = /* @__PURE__ */ new Set();
+    for (const start of starts) {
+      const stepId = stepIdOf(start);
+      let match;
+      if (legacyEvent(start) === "run_started") {
+        const candidates = completes.filter(
+          (c) => !usedCompletes.has(c.eventId) && legacyEvent(c) === "run_completed"
+        );
+        if (candidates.length > 1) {
+          diagnostics.push({
+            code: "AI_LOGICAL_PAIR_AMBIGUOUS",
+            message: `Multiple run_completed rows for run ${runId}; using first by eventId.`,
+            eventIds: candidates.map((c) => c.eventId)
+          });
+          candidates.sort((a, b) => a.eventId.localeCompare(b.eventId));
+        }
+        match = candidates[0];
+      } else if (stepId) {
+        const candidates = completes.filter(
+          (c) => !usedCompletes.has(c.eventId) && legacyEvent(c) === "step_completed" && stepIdOf(c) === stepId
+        );
+        if (candidates.length > 1) {
+          diagnostics.push({
+            code: "AI_LOGICAL_PAIR_AMBIGUOUS",
+            message: `Multiple step_completed rows for stepId ${stepId}; using first by eventId.`,
+            eventIds: candidates.map((c) => c.eventId)
+          });
+          candidates.sort((a, b) => a.eventId.localeCompare(b.eventId));
+        }
+        match = candidates[0];
+      }
+      if (match) {
+        usedCompletes.add(match.eventId);
+        absorbedIds.add(match.eventId);
+        const paired = pairStartComplete(start, match);
+        logical.push(paired);
+        logicalByRawId.set(start.eventId, paired);
+        logicalByRawId.set(match.eventId, paired);
+        if (stepId) stepIdToLogicalId.set(`${runId}:${stepId}`, paired.eventId);
+      } else {
+        diagnostics.push({
+          code: "AI_LOGICAL_PAIR_UNMATCHED_START",
+          message: `No matching complete for start ${start.eventId}.`,
+          eventIds: [start.eventId]
+        });
+        const alone = asLogical(start);
+        logical.push(alone);
+        logicalByRawId.set(start.eventId, alone);
+        if (stepId) stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
     }
-  }
-  for (const R of right) {
-    if (!usedRight.has(R.id)) {
-      pairs.push([void 0, R]);
+    for (const complete of completes) {
+      if (usedCompletes.has(complete.eventId)) continue;
+      diagnostics.push({
+        code: "AI_LOGICAL_PAIR_UNMATCHED_COMPLETE",
+        message: `No matching start for complete ${complete.eventId}.`,
+        eventIds: [complete.eventId]
+      });
+      const alone = asLogical(complete);
+      logical.push(alone);
+      logicalByRawId.set(complete.eventId, alone);
+      const stepId = stepIdOf(complete);
+      if (stepId && !stepIdToLogicalId.has(`${runId}:${stepId}`)) {
+        stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
+    }
+    for (const event of others) {
+      const alone = asLogical(event);
+      logical.push(alone);
+      logicalByRawId.set(event.eventId, alone);
+      const stepId = stepIdOf(event);
+      if (stepId && !stepIdToLogicalId.has(`${runId}:${stepId}`)) {
+        stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
     }
   }
-  return pairs;
-}
-function compareLeafSteps(L, R, segments, opts, out) {
-  const path18 = buildPath(segments);
-  if (L.name !== R.name) {
-    out.push({
-      kind: "structure",
-      severity: "warning",
-      message: "Step name differs",
-      path: path18,
-      left: L.name,
-      right: R.name
+  const logicalById = new Map(logical.map((e) => [e.eventId, e]));
+  const normalized = [];
+  for (const event of logical) {
+    const originalParentId = event.parentId;
+    if (!originalParentId) {
+      normalized.push(event);
+      continue;
+    }
+    let nextParent = originalParentId;
+    let remapped = false;
+    const viaAbsorbed = logicalByRawId.get(originalParentId);
+    if (viaAbsorbed && viaAbsorbed.eventId !== originalParentId) {
+      nextParent = viaAbsorbed.eventId;
+      remapped = true;
+    } else if (!logicalById.has(originalParentId)) {
+      const viaStep = stepIdToLogicalId.get(`${event.runId}:${originalParentId}`);
+      if (viaStep) {
+        nextParent = viaStep;
+        remapped = true;
+      }
+    }
+    if (!remapped) {
+      if (originalParentId === event.eventId) {
+        diagnostics.push({
+          code: "AI_LOGICAL_SELF_PARENT_REMOVED",
+          message: formatProgrammaticDiagnostic(
+            "AI_TRACE_RELATIONSHIP_SELF_PARENT",
+            `Removed self-parent edge on ${event.eventId}.`
+          ),
+          eventIds: [event.eventId]
+        });
+        const { parentId: _drop, ...rest } = event;
+        normalized.push({
+          ...rest,
+          projection: {
+            ...event.projection,
+            parentNormalized: true,
+            originalParentId
+          }
+        });
+        continue;
+      }
+      if (!logicalById.has(originalParentId) && !logicalByRawId.has(originalParentId)) {
+        const mapping = event.attributes?.parentMapping;
+        const unresolved = mapping === "unresolved" || event.attributes?.parentUnresolved === true || event.attributes?.unresolvedParent === true || // LangGraph/framework scaffolding sentinel labels are not event ids.
+        /^LangGraph$/i.test(originalParentId) || originalParentId.startsWith("unresolved:");
+        if (!unresolved) {
+          diagnostics.push({
+            code: "AI_LOGICAL_PARENT_UNRESOLVED",
+            message: `Parent ${originalParentId} unresolved for ${event.eventId}.`,
+            eventIds: [event.eventId]
+          });
+        }
+      }
+      normalized.push(event);
+      continue;
+    }
+    if (nextParent === event.eventId) {
+      diagnostics.push({
+        code: "AI_LOGICAL_SELF_PARENT_REMOVED",
+        message: formatProgrammaticDiagnostic(
+          "AI_TRACE_RELATIONSHIP_SELF_PARENT",
+          `Removed self-parent edge on ${event.eventId} (was ${originalParentId}).`
+        ),
+        eventIds: [event.eventId]
+      });
+      const { parentId: _drop, ...rest } = event;
+      normalized.push({
+        ...rest,
+        projection: {
+          ...event.projection,
+          parentNormalized: true,
+          originalParentId
+        }
+      });
+      continue;
+    }
+    diagnostics.push({
+      code: "AI_LOGICAL_PARENT_REMAPPED",
+      message: `Remapped parent ${originalParentId} \u2192 ${nextParent} for ${event.eventId}.`,
+      eventIds: [event.eventId]
     });
-  }
-  if ((L.type ?? "") !== (R.type ?? "")) {
-    out.push({
-      kind: "step-type",
-      severity: "warning",
-      message: "Step type differs",
-      path: path18,
-      left: L.type,
-      right: R.type
+    normalized.push({
+      ...event,
+      parentId: nextParent,
+      projection: {
+        ...event.projection,
+        parentNormalized: true,
+        originalParentId
+      }
     });
   }
-  if ((L.status ?? "") !== (R.status ?? "")) {
-    out.push({
-      kind: "step-status",
-      severity: "warning",
-      message: "Step status differs",
-      path: path18,
-      left: L.status,
-      right: R.status
-    });
+  const rawIndex = new Map(events.map((e, i) => [e.eventId, i]));
+  normalized.sort((a, b) => {
+    const ai = rawIndex.get(a.sourceEventIds[0]) ?? 0;
+    const bi = rawIndex.get(b.sourceEventIds[0]) ?? 0;
+    return ai - bi || a.eventId.localeCompare(b.eventId);
+  });
+  return {
+    logicalEvents: Object.freeze(normalized),
+    diagnostics: Object.freeze(diagnostics)
+  };
+}
+function resolveCanonicalToolName(event) {
+  const attrs = event.attributes;
+  const direct = pickString(attrs, ["toolName", "tool"]);
+  if (direct) return direct;
+  const metadata = attrs?.metadata;
+  if (isRecord5(metadata)) {
+    const nested = pickString(metadata, ["toolName", "tool"]);
+    if (nested) return nested;
   }
-  const le = L.error ?? "";
-  const re = R.error ?? "";
-  if (le !== re) {
-    out.push({
-      kind: "error",
-      severity: "error",
-      message: "Step error message differs",
-      path: path18,
-      left: le || void 0,
-      right: re || void 0
-    });
-  }
-  if (!opts.ignoreDuration) {
-    const ld = L.durationMs;
-    const rd = R.durationMs;
-    const th = opts.durationThresholdMs;
-    let differs = false;
-    if (ld === void 0 && rd === void 0) differs = false;
-    else if (ld === void 0 || rd === void 0) differs = true;
-    else differs = Math.abs(ld - rd) > th;
-    if (differs) {
-      out.push({
-        kind: "duration",
-        severity: "info",
-        message: "Step duration differs",
-        path: path18,
-        left: ld,
-        right: rd
-      });
-    }
-  }
-  const lm = stableJson(L.metadata ?? {});
-  const rm2 = stableJson(R.metadata ?? {});
-  if (lm !== rm2) {
-    out.push({
-      kind: "metadata",
-      severity: "info",
-      message: "Step metadata differs",
-      path: path18,
-      left: L.metadata,
-      right: R.metadata
-    });
-  }
-  const lo = stableJson(L.outputPreview ?? null);
-  const ro = stableJson(R.outputPreview ?? null);
-  if (lo !== ro) {
-    out.push({
-      kind: "output",
-      severity: "info",
-      message: "Output preview differs",
-      path: path18,
-      left: L.outputPreview,
-      right: R.outputPreview
-    });
+  for (const prefix of ["tool:", "function:", "mcp-tools:"]) {
+    if (event.name.startsWith(prefix)) return event.name.slice(prefix.length);
   }
+  return event.name;
 }
-function compareRecursive(L, R, segments, opts, out) {
-  compareLeafSteps(L, R, segments, opts, out);
-  const pairs = pairSteps(L.children, R.children);
-  let ci = 0;
-  for (const [lch, rch] of pairs) {
-    if (lch !== void 0 && rch !== void 0) {
-      compareRecursive(lch, rch, [...segments, pathSeg(lch, ci)], opts, out);
-    } else if (lch !== void 0) {
-      out.push({
-        kind: "step-removed",
-        severity: "warning",
-        message: `Step only in left run: ${lch.name}`,
-        path: buildPath([...segments, pathSeg(lch, ci)]),
-        left: lch.id,
-        right: void 0
-      });
-    } else if (rch !== void 0) {
-      out.push({
-        kind: "step-added",
-        severity: "warning",
-        message: `Step only in right run: ${rch.name}`,
-        path: buildPath([...segments, pathSeg(rch, ci)]),
-        left: void 0,
-        right: rch.id
-      });
-    }
-    ci += 1;
+function pickString(record, keys) {
+  if (!record) return void 0;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
   }
+  return void 0;
 }
-function mergeDiffDefaults(options) {
+
+// packages/core/src/checks/trace-facts.ts
+formatProgrammaticDiagnostic(
+  "AI_TRACE_FACTS_INPUT_NOT_NORMALIZED"
+);
+
+// packages/core/src/checks/index.ts
+var SEVERITY_RANK = {
+  error: 0,
+  warning: 1,
+  info: 2
+};
+var STATUS_RANK = {
+  fail: 0,
+  warning: 1,
+  pass: 2
+};
+function compareStrings(a, b) {
+  return (a ?? "").localeCompare(b ?? "");
+}
+function diagnostic(code, message, ruleId) {
   return {
-    ignoreDuration: false,
-    durationThresholdMs: DEFAULT_THRESHOLD_MS,
-    focus: "all",
-    check: "all"
+    code,
+    message,
+    severity: "error",
+    ...ruleId ? { ruleId } : {}
   };
 }
-function kindMatchesFilter(kind, merged) {
-  return true;
+function emptySummary() {
+  return {
+    passed: 0,
+    failed: 0,
+    warnings: 0,
+    errors: 0,
+    rulesEvaluated: 0
+  };
 }
-function diffRuns(left, right, options) {
-  const merged = mergeDiffDefaults();
-  const opts = {
-    ignoreDuration: merged.ignoreDuration,
-    durationThresholdMs: merged.durationThresholdMs
+function errorResult(input, diagnostics, selectedRun, ruleExecutions = []) {
+  return {
+    ok: false,
+    status: "error",
+    format: input.read.format,
+    ...selectedRun ? { runId: selectedRun.runId } : {},
+    summary: {
+      ...emptySummary(),
+      errors: diagnostics.filter((item) => item.severity === "error").length,
+      rulesEvaluated: ruleExecutions.length
+    },
+    findings: [],
+    diagnostics: [...diagnostics],
+    ruleExecutions: [...ruleExecutions]
   };
-  const raw = [];
-  if ((left.status ?? "") !== (right.status ?? "")) {
-    raw.push({
-      kind: "run-status",
-      severity: "warning",
-      message: "Run completion status differs",
-      left: left.status,
-      right: right.status
-    });
+}
+function flattenNodes(nodes) {
+  return nodes.flatMap((node) => [node, ...flattenNodes(node.children)]);
+}
+function buildFacts(input, selectedRun) {
+  const scopedRuns = selectedRun ? [selectedRun] : input.read.runs;
+  const scopedRunIds = new Set(scopedRuns.map((run) => run.runId));
+  const scopedEvents = selectedRun === void 0 ? input.read.events : input.read.events.filter((event) => scopedRunIds.has(event.runId));
+  const nodes = flattenNodes(scopedRuns.flatMap((run) => run.children));
+  const nodesByEventId = /* @__PURE__ */ new Map();
+  const childrenByParentId = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodesByEventId.set(node.event.eventId, node);
+    const parentId = node.event.parentId;
+    if (parentId) {
+      const children = childrenByParentId.get(parentId) ?? [];
+      children.push(node);
+      childrenByParentId.set(parentId, children);
+    }
   }
-  {
-    const ld = left.durationMs;
-    const rd = right.durationMs;
-    const th = merged.durationThresholdMs;
-    let differs = false;
-    if (ld === void 0 && rd === void 0) differs = false;
-    else if (ld === void 0 || rd === void 0) differs = true;
-    else differs = Math.abs(ld - rd) > th;
-    if (differs) {
-      raw.push({
-        kind: "duration",
-        severity: "info",
-        message: "Run duration differs",
-        left: ld,
-        right: rd
-      });
+  const projection = projectLogicalEvents(scopedEvents);
+  return {
+    format: input.read.format,
+    runs: Object.freeze([...input.read.runs]),
+    events: Object.freeze([...scopedEvents]),
+    logicalEvents: projection.logicalEvents,
+    logicalProjectionDiagnostics: projection.diagnostics,
+    readerWarnings: Object.freeze([...input.read.warnings]),
+    unsupportedFields: Object.freeze([...input.read.unsupportedFields]),
+    sourceFiles: Object.freeze([...input.read.sourceFiles]),
+    nodesByEventId,
+    childrenByParentId,
+    rootNodes: Object.freeze(scopedRuns.flatMap((run) => run.children))
+  };
+}
+function resolveSelectedRun(input, runId) {
+  if (input.selectedRun) {
+    if (runId && input.selectedRun.runId !== runId) {
+      return {
+        diagnostics: [
+          diagnostic(
+            "AI_CHECK_INVALID_ARGUMENTS",
+            `Selected run ${input.selectedRun.runId} does not match requested run ${runId}.`
+          )
+        ]
+      };
     }
+    return { run: input.selectedRun, diagnostics: [] };
   }
-  const pairs = pairSteps(left.steps, right.steps);
-  let idx = 0;
-  for (const [ls, rs] of pairs) {
-    if (ls !== void 0 && rs !== void 0) {
-      compareRecursive(ls, rs, [pathSeg(ls, idx)], opts, raw);
-      idx += 1;
-    } else if (ls !== void 0) {
-      raw.push({
-        kind: "step-removed",
-        severity: "warning",
-        message: `Step only in left run: ${ls.name}`,
-        path: buildPath([pathSeg(ls, idx)]),
-        left: ls.id,
-        right: void 0
-      });
-      idx += 1;
-    } else if (rs !== void 0) {
-      raw.push({
-        kind: "step-added",
-        severity: "warning",
-        message: `Step only in right run: ${rs.name}`,
-        path: buildPath([pathSeg(rs, idx)]),
-        left: void 0,
-        right: rs.id
-      });
-      idx += 1;
+  if (runId) {
+    const run = input.read.runs.find((candidate) => candidate.runId === runId);
+    if (!run) {
+      return {
+        diagnostics: [
+          diagnostic("AI_CHECK_RUN_SELECTION_REQUIRED", `Run not found: ${runId}.`)
+        ]
+      };
     }
+    return { run, diagnostics: [] };
   }
-  const differences = raw.filter((d) => kindMatchesFilter(d.kind));
-  let errors = 0;
-  let warnings = 0;
-  let info = 0;
-  for (const d of differences) {
-    if (d.severity === "error") errors += 1;
-    else if (d.severity === "warning") warnings += 1;
-    else info += 1;
-  }
-  const firstVisible = differences[0];
-  const firstDivergence = firstVisible !== void 0 ? {
-    kind: "first-divergence",
-    severity: firstVisible.severity,
-    message: `First divergence: ${firstVisible.message}`,
-    path: firstVisible.path,
-    left: firstVisible.left,
-    right: firstVisible.right
-  } : void 0;
-  const summary = {
-    leftRunId: left.runId,
-    rightRunId: right.runId,
-    totalDifferences: differences.length,
-    errors,
-    warnings,
-    info,
-    firstDivergence
-  };
-  return { summary, differences };
-}
-
-// packages/core/src/evidence/zip.ts
-(() => {
-  const table = new Uint32Array(256);
-  for (let n = 0; n < 256; n += 1) {
-    let c = n;
-    for (let k = 0; k < 8; k += 1) {
-      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
-    }
-    table[n] = c >>> 0;
-  }
-  return table;
-})();
-
-// packages/core/src/suite/types.ts
-var DEFAULT_SUITE_CONFIG_NAMES = [
-  "agent-inspect.suite.json",
-  "agent-inspect.suite.js",
-  "agent-inspect.suite.mjs",
-  "agent-inspect.suite.cjs"
-];
-function diagnostic(code, message, severity = "error", caseId) {
-  return { code, message, severity, ...{} };
-}
-function asString(value, label) {
-  if (value === void 0) return void 0;
-  if (typeof value !== "string" || value.trim() === "") {
-    throw new Error(`${label} must be a non-empty string.`);
-  }
-  return value.trim();
-}
-function asStringArray(value, label) {
-  if (value === void 0) return void 0;
-  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-    throw new Error(`${label} must be an array of strings.`);
+  if (input.read.runs.length === 1) {
+    return { run: input.read.runs[0], diagnostics: [] };
   }
-  return value;
-}
-function asPositiveNumber(value, label) {
-  if (value === void 0) return void 0;
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    throw new Error(`${label} must be a non-negative number.`);
+  if (input.read.runs.length === 0) {
+    return {
+      diagnostics: [
+        diagnostic(
+          "AI_CHECK_RUN_SELECTION_REQUIRED",
+          formatProgrammaticDiagnostic(
+            "AI_TRACE_CONTRACT_RUN_SELECTION_REQUIRED",
+            "No runs are available for checks."
+          )
+        )
+      ]
+    };
   }
-  return value;
+  return {
+    diagnostics: [
+      diagnostic(
+        "AI_CHECK_RUN_SELECTION_REQUIRED",
+        formatProgrammaticDiagnostic("AI_TRACE_CONTRACT_RUN_SELECTION_REQUIRED")
+      )
+    ]
+  };
 }
-function validateCaseConfig(value, index) {
+function selectRules(rules, selectedIds) {
   const diagnostics = [];
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    diagnostics.push(
-      diagnostic("AI_SUITE_CONFIG_INVALID", `cases[${index}] must be an object.`)
-    );
-    return { diagnostics };
-  }
-  const raw = value;
-  try {
-    const id = asString(raw.id, `cases[${index}].id`);
-    if (id === void 0) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (byId.has(rule.id)) {
       diagnostics.push(
-        diagnostic("AI_SUITE_CONFIG_INVALID", `cases[${index}].id is required.`)
+        diagnostic("AI_CHECK_INVALID_CONFIG", `Duplicate trace check rule id: ${rule.id}.`, rule.id)
       );
-      return { diagnostics };
+      continue;
+    }
+    byId.set(rule.id, rule);
+  }
+  if (selectedIds && selectedIds.length > 0) {
+    const selected = new Set(selectedIds);
+    for (const id of selected) {
+      if (!byId.has(id)) {
+        diagnostics.push(
+          diagnostic("AI_CHECK_INVALID_CONFIG", `Unknown trace check rule id: ${id}.`, id)
+        );
+      }
     }
-    const trace = asString(raw.trace, `cases[${index}].trace`);
-    const runId = asString(raw.runId, `cases[${index}].runId`);
-    const input = asString(raw.input, `cases[${index}].input`);
     return {
-      caseConfig: {
-        id,
-        ...trace !== void 0 ? { trace } : {},
-        ...runId !== void 0 ? { runId } : {},
-        ...input !== void 0 ? { input } : {},
-        ...asStringArray(raw.requireTools, `cases[${index}].requireTools`) !== void 0 ? { requireTools: asStringArray(raw.requireTools, `cases[${index}].requireTools`) } : {},
-        ...asStringArray(raw.forbidTools, `cases[${index}].forbidTools`) !== void 0 ? { forbidTools: asStringArray(raw.forbidTools, `cases[${index}].forbidTools`) } : {},
-        ...asPositiveNumber(raw.maxDurationMs, `cases[${index}].maxDurationMs`) !== void 0 ? {
-          maxDurationMs: asPositiveNumber(
-            raw.maxDurationMs,
-            `cases[${index}].maxDurationMs`
-          )
-        } : {},
-        ...asStringArray(
-          raw.expectedObservations,
-          `cases[${index}].expectedObservations`
-        ) !== void 0 ? {
-          expectedObservations: asStringArray(
-            raw.expectedObservations,
-            `cases[${index}].expectedObservations`
-          )
-        } : {}
-      },
+      rules: [...byId.values()].filter((rule) => selected.has(rule.id)).sort(compareRules),
       diagnostics
     };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    diagnostics.push(diagnostic("AI_SUITE_CONFIG_INVALID", message));
-    return { diagnostics };
   }
+  return { rules: [...byId.values()].sort(compareRules), diagnostics };
 }
-function normalizeSuiteConfig(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error("Suite config must export an object.");
-  }
-  const raw = value;
-  const name = asString(raw.name, "name");
-  const traces = asString(raw.traces, "traces");
-  if (name === void 0) throw new Error("name is required.");
-  if (traces === void 0) throw new Error("traces is required.");
-  if (!Array.isArray(raw.cases) || raw.cases.length === 0) {
-    throw new Error("cases must be a non-empty array.");
-  }
-  const cases = [];
-  for (let index = 0; index < raw.cases.length; index += 1) {
-    const { caseConfig, diagnostics } = validateCaseConfig(raw.cases[index], index);
-    if (diagnostics.length > 0) {
-      throw new Error(diagnostics.map((item) => item.message).join("; "));
+function compareRules(a, b) {
+  return a.id.localeCompare(b.id);
+}
+function eventTimestamp(finding, eventById) {
+  const eventId = finding.evidence[0]?.eventId;
+  return eventId ? eventById.get(eventId)?.timestamp ?? "" : "";
+}
+function compareFindings(eventById) {
+  return (a, b) => {
+    if (SEVERITY_RANK[a.severity] !== SEVERITY_RANK[b.severity]) {
+      return SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity];
     }
-    if (caseConfig !== void 0) cases.push(caseConfig);
-  }
-  const ids = /* @__PURE__ */ new Set();
-  for (const suiteCase of cases) {
-    if (ids.has(suiteCase.id)) {
-      throw new Error(`Duplicate case id "${suiteCase.id}".`);
+    const byRule = a.ruleId.localeCompare(b.ruleId);
+    if (byRule !== 0) return byRule;
+    if (STATUS_RANK[a.status] !== STATUS_RANK[b.status]) {
+      return STATUS_RANK[a.status] - STATUS_RANK[b.status];
     }
-    ids.add(suiteCase.id);
+    const byRun = compareStrings(a.evidence[0]?.runId, b.evidence[0]?.runId);
+    if (byRun !== 0) return byRun;
+    const byTime = eventTimestamp(a, eventById).localeCompare(eventTimestamp(b, eventById));
+    if (byTime !== 0) return byTime;
+    const byEvent = compareStrings(a.evidence[0]?.eventId, b.evidence[0]?.eventId);
+    if (byEvent !== 0) return byEvent;
+    return compareStrings(a.evidence[0]?.path, b.evidence[0]?.path);
+  };
+}
+function normalizeFinding(rule, finding) {
+  return {
+    ruleId: finding.ruleId || rule.id,
+    severity: finding.severity ?? rule.defaultSeverity,
+    status: finding.status,
+    message: finding.message,
+    ...finding.expected !== void 0 ? { expected: finding.expected } : {},
+    ...finding.actual !== void 0 ? { actual: finding.actual } : {},
+    evidence: [...finding.evidence ?? []],
+    ...finding.category !== void 0 ? { category: finding.category } : {},
+    ...finding.confidence !== void 0 ? { confidence: finding.confidence } : {},
+    ...finding.detector !== void 0 ? { detector: finding.detector } : {},
+    ...finding.action !== void 0 ? { action: finding.action } : {}
+  };
+}
+function summarize(findings, diagnostics, rulesEvaluated) {
+  return {
+    passed: findings.filter((finding) => finding.status === "pass").length,
+    failed: findings.filter(
+      (finding) => finding.status === "fail" && finding.severity === "error"
+    ).length,
+    warnings: findings.filter(
+      (finding) => finding.status === "warning" || finding.severity === "warning"
+    ).length,
+    errors: diagnostics.filter((item) => item.severity === "error").length,
+    rulesEvaluated
+  };
+}
+function classifyRuleExecution(findings, threw) {
+  if (findings.some((finding) => finding.status === "fail" && finding.severity === "error")) {
+    return "fail";
   }
-  const redactionProfile = raw.redactionProfile === "local" || raw.redactionProfile === "share" || raw.redactionProfile === "strict" ? raw.redactionProfile : void 0;
-  if (raw.redactionProfile !== void 0 && redactionProfile === void 0) {
-    throw new Error('redactionProfile must be "local", "share", or "strict".');
+  if (findings.some(
+    (finding) => finding.status === "warning" || finding.severity === "warning"
+  )) {
+    return "warning";
   }
-  const config = { name, traces, cases };
-  if (raw.checks !== void 0) {
-    if (typeof raw.checks !== "object" || Array.isArray(raw.checks)) {
-      throw new Error("checks must be an object.");
-    }
-    config.checks = raw.checks;
+  return "pass";
+}
+function stringAttr(event, keys) {
+  for (const key of keys) {
+    const value = event.attributes?.[key];
+    if (typeof value === "string" && value.trim() !== "") return value;
   }
-  if (raw.eval !== void 0) {
-    if (typeof raw.eval !== "object" || Array.isArray(raw.eval)) {
-      throw new Error("eval must be an object.");
-    }
-    config.eval = raw.eval;
+  return void 0;
+}
+function metadataStringAttr(event, keys) {
+  const metadata = event.attributes?.metadata;
+  if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+    return void 0;
   }
-  if (raw.artifacts !== void 0) {
-    if (typeof raw.artifacts !== "object" || Array.isArray(raw.artifacts)) {
-      throw new Error("artifacts must be an object.");
-    }
-    const outputDir = asString(
-      raw.artifacts.outputDir,
-      "artifacts.outputDir"
-    );
-    config.artifacts = outputDir !== void 0 ? { outputDir } : {};
-  }
-  if (raw.baseline !== void 0) {
-    const baseline = asString(raw.baseline, "baseline");
-    if (baseline !== void 0) config.baseline = baseline;
-  }
-  if (raw.candidate !== void 0) {
-    const candidate = asString(raw.candidate, "candidate");
-    if (candidate !== void 0) config.candidate = candidate;
-  }
-  if (redactionProfile !== void 0) config.redactionProfile = redactionProfile;
-  return config;
-}
-
-// packages/core/src/suite/load.ts
-var CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".js", ".mjs", ".cjs"]);
-var TS_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts"]);
-function diagnostic2(code, message) {
-  return { code, message, severity: "error" };
-}
-async function fileExists(filePath) {
-  try {
-    await access(filePath);
-    return true;
-  } catch {
-    return false;
+  const record = metadata;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim() !== "") return value;
   }
+  return void 0;
 }
-async function resolveSuiteConfigPath(options = {}) {
-  const cwd = path15.resolve(options.cwd ?? process.cwd());
-  if (options.configPath !== void 0 && options.configPath.trim() !== "") {
-    return path15.resolve(cwd, options.configPath.trim());
-  }
-  for (const name of DEFAULT_SUITE_CONFIG_NAMES) {
-    const candidate = path15.join(cwd, name);
-    if (await fileExists(candidate)) return candidate;
+function stripPrefix(name, prefixes) {
+  for (const prefix of prefixes) {
+    if (name.startsWith(prefix)) return name.slice(prefix.length);
   }
-  throw new Error(
-    `No suite config found. Create one with \`agent-inspect suite init\` or pass --config.`
-  );
+  return name;
 }
-async function loadSuiteConfig(options = {}) {
-  let configPath;
-  try {
-    configPath = await resolveSuiteConfigPath(options);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw Object.assign(new Error(message), {
-      diagnostics: [diagnostic2("AI_SUITE_CONFIG_LOAD_FAILED", message)]
-    });
-  }
-  const extension = path15.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: [diagnostic2("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: [diagnostic2("AI_SUITE_CONFIG_LOAD_FAILED", message)]
-    });
-  }
-  try {
-    let raw;
-    if (extension === ".json") {
-      raw = JSON.parse(await readFile(configPath, "utf-8"));
-    } else {
-      const mod = await import(pathToFileURL(configPath).href);
-      raw = "default" in mod ? mod.default : mod;
-    }
-    const config = normalizeSuiteConfig(raw);
-    return {
-      config,
-      configPath,
-      configDir: path15.dirname(configPath)
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw Object.assign(new Error(message), {
-      diagnostics: [diagnostic2("AI_SUITE_CONFIG_LOAD_FAILED", message)]
-    });
-  }
+function eventEvidence(event, path18) {
+  return {
+    runId: event.runId,
+    eventId: event.eventId,
+    parentId: event.parentId,
+    traceId: event.trace?.traceId,
+    spanId: event.trace?.spanId,
+    kind: event.kind,
+    name: event.name,
+    status: event.status,
+    ...path18 ? { path: path18 } : {}
+  };
 }
-async function exists(filePath) {
-  try {
-    await access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
+function runEvidence(run) {
+  return run ? [{ runId: run.runId, name: run.name, status: run.status }] : [];
 }
-async function resolveSuiteCaseTrace(suiteCase, options) {
-  if (suiteCase.trace !== void 0) {
-    const tracePath = path15.resolve(options.configDir, suiteCase.trace);
-    if (await exists(tracePath)) {
-      return { caseId: suiteCase.id, tracePath, missing: false };
-    }
-    return {
-      caseId: suiteCase.id,
-      tracePath,
-      missing: true,
-      reason: `trace file not found: ${suiteCase.trace}`
-    };
-  }
-  const runKey = suiteCase.runId ?? suiteCase.id;
-  const directPath = getTraceFilePath(runKey, options.tracesDir);
-  if (await exists(directPath)) {
-    return { caseId: suiteCase.id, tracePath: directPath, runId: runKey, missing: false };
-  }
-  const nestedPath = path15.join(options.tracesDir, `${path15.basename(runKey)}.jsonl`);
-  if (await exists(nestedPath)) {
-    return { caseId: suiteCase.id, tracePath: nestedPath, runId: runKey, missing: false };
-  }
+function failFinding(ruleId, message, evidence, expected, actual, meta) {
   return {
-    caseId: suiteCase.id,
-    runId: runKey,
-    missing: true,
-    reason: `no trace found for run id "${runKey}" under ${options.tracesDir}`
+    ruleId,
+    severity: meta?.severity ?? "error",
+    status: meta?.status ?? "fail",
+    message,
+    ...expected !== void 0 ? { expected } : {},
+    ...actual !== void 0 ? { actual } : {},
+    evidence: [...evidence],
+    ...{},
+    ...{},
+    ...{},
+    ...{}
   };
 }
-
-// packages/core/src/diagnostics/programmatic.ts
-var PROGRAMMATIC_DIAGNOSTIC_SPECS = Object.freeze({
-  AI_TRACE_INPUT_INVALID: {
-    code: "AI_TRACE_INPUT_INVALID",
-    summary: 'Expected { type: "file", path }, { type: "directory", path }, { type: "string", content }, { type: "buffer", content }, or { type: "stdin" }.',
-    remediation: "For a file path, use openTraceFile(path).",
-    relatedCodes: ["invalid_input"]
-  },
-  AI_TRACE_FORMAT_UNSUPPORTED: {
-    code: "AI_TRACE_FORMAT_UNSUPPORTED",
-    summary: "No trace reader could detect the input format.",
-    remediation: "Pass an AgentInspect JSONL file via openTraceFile, or set options.format to a registered reader.",
-    relatedCodes: ["unsupported_format"]
-  },
-  AI_TRACE_FORMAT_AMBIGUOUS: {
-    code: "AI_TRACE_FORMAT_AMBIGUOUS",
-    summary: "Multiple trace readers matched the input with equal confidence.",
-    remediation: "Set options.format explicitly to disambiguate the reader.",
-    relatedCodes: ["ambiguous_format"]
-  },
-  AI_TRACE_FACTS_INPUT_NOT_NORMALIZED: {
-    code: "AI_TRACE_FACTS_INPUT_NOT_NORMALIZED",
-    summary: "TraceFacts requires TraceReadResult or PersistedInspectEvent[].",
-    remediation: "Use openTraceFile() to normalize a JSONL trace first."
-  },
-  AI_TRACE_CONTRACT_RUN_SELECTION_REQUIRED: {
-    code: "AI_TRACE_CONTRACT_RUN_SELECTION_REQUIRED",
-    summary: "Multiple runs are available; select a run before executing checks.",
-    remediation: "Pass options.runId or TraceCheckInput.selectedRun.",
-    relatedCodes: ["AI_CHECK_RUN_SELECTION_REQUIRED"]
-  },
-  AI_TRACE_RELATIONSHIP_SELF_PARENT: {
-    code: "AI_TRACE_RELATIONSHIP_SELF_PARENT",
-    summary: "A parentId equals its own event/step id.",
-    remediation: "Reject at capture (AI_LANGGRAPH_SELF_PARENT_REJECTED) or drop via logical projection; do not invent replacement parents.",
-    relatedCodes: [
-      "AI_LANGGRAPH_SELF_PARENT_REJECTED",
-      "AI_LOGICAL_SELF_PARENT_REMOVED"
-    ]
-  },
-  AI_TRACE_RELATIONSHIP_CYCLE: {
-    code: "AI_TRACE_RELATIONSHIP_CYCLE",
-    summary: "Trace contains a parentId cycle.",
-    remediation: "Use visibility-first tree linking for legacy fixtures; prefer acyclic capture for new adapter output.",
-    relatedCodes: ["structure.cycle"]
-  }
-});
-function formatProgrammaticDiagnostic(code, detail) {
-  const spec = PROGRAMMATIC_DIAGNOSTIC_SPECS[code];
-  const summary = detail?.trim() ? detail.trim() : spec.summary;
-  return `${code}: ${summary} Remediation: ${spec.remediation}`;
+function toolName(event) {
+  return resolveCanonicalToolName(event);
 }
-
-// packages/core/src/safety/sensitive-key.ts
-function normalizeSensitiveKey(value) {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+function semanticEvents(context) {
+  return context.logicalEvents ?? context.events;
 }
-new Set(
-  [
-    "tokens",
-    "max_tokens",
-    "min_tokens",
-    "ls_max_tokens",
-    "token_count",
-    "token_limit",
-    "token_budget",
-    "input_tokens",
-    "output_tokens",
-    "total_tokens",
-    "cached_tokens",
-    "prompt_tokens",
-    "completion_tokens"
-  ].map(normalizeSensitiveKey)
-);
-
-// packages/core/src/checks/logical-events.ts
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function llmModel(event) {
+  const keys = ["model", "modelId", "responseModelId", "modelName", "model_name"];
+  return stringAttr(event, keys) ?? metadataStringAttr(event, keys) ?? stripPrefix(event.name, ["llm:", "generation:", "transcription:", "speech:"]);
 }
-function legacyEvent(event) {
-  const value = event.attributes?.legacyEvent;
-  return typeof value === "string" ? value : void 0;
+function llmProvider(event) {
+  const keys = ["provider", "providerName", "provider_name"];
+  return stringAttr(event, keys) ?? metadataStringAttr(event, keys);
 }
-function stepIdOf(event) {
-  const value = event.attributes?.stepId;
-  if (typeof value === "string" && value.trim() !== "") return value;
-  return void 0;
+function llmFinishReason(event) {
+  const keys = ["finishReason", "rawFinishReason", "finish_reason"];
+  return stringAttr(event, keys) ?? metadataStringAttr(event, keys);
 }
-function cloneEvent(event) {
-  return {
-    ...event,
-    ...event.attributes !== void 0 ? { attributes: { ...event.attributes } } : {},
-    ...event.error !== void 0 ? { error: { ...event.error } } : {},
-    ...event.tokenUsage !== void 0 ? { tokenUsage: { ...event.tokenUsage } } : {},
-    ...event.source !== void 0 ? { source: { ...event.source } } : {}
-  };
+function finishedEvents(context, kind) {
+  return semanticEvents(context).filter(
+    (event) => (event.kind === kind) && event.status !== "running"
+  );
 }
-function mergeAttributes(start, complete) {
-  const merged = {
-    ...isRecord5(complete.attributes) ? complete.attributes : {},
-    ...isRecord5(start.attributes) ? start.attributes : {}
-  };
-  merged.legacyEvent = start.attributes?.legacyEvent ?? complete.attributes?.legacyEvent;
-  merged.legacyCompleteEvent = complete.attributes?.legacyEvent;
-  if (complete.attributes?.errorStack !== void 0) {
-    merged.errorStack = complete.attributes.errorStack;
-  }
-  return Object.keys(merged).length > 0 ? merged : void 0;
+function toolInvocationEvents(context) {
+  return semanticEvents(context).filter((event) => event.kind === "TOOL");
 }
-function pairStartComplete(start, complete) {
-  const attributes = mergeAttributes(start, complete);
-  const paired = {
-    ...cloneEvent(start),
-    status: complete.status,
-    timestamp: complete.timestamp ?? start.timestamp,
-    ...complete.endedAt !== void 0 ? { endedAt: complete.endedAt } : {},
-    ...complete.durationMs !== void 0 ? { durationMs: complete.durationMs } : {},
-    ...complete.error !== void 0 ? { error: { ...complete.error } } : {},
-    ...complete.tokenUsage !== void 0 && start.tokenUsage === void 0 ? { tokenUsage: { ...complete.tokenUsage } } : {},
-    ...attributes !== void 0 ? { attributes } : {}
-  };
+function createRunStatusRule(options = {}) {
+  const expected = options.expected ?? "ok";
+  const allowIncomplete = options.allowIncomplete === true;
   return {
-    ...paired,
-    sourceEventIds: Object.freeze([start.eventId, complete.eventId]),
-    projection: {
-      paired: true,
-      absorbedEventIds: Object.freeze([complete.eventId]),
-      parentNormalized: false,
-      ...start.parentId !== void 0 ? { originalParentId: start.parentId } : {}
+    id: "run.status",
+    category: "run",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const findings = [];
+      const actual = context.selectedRun?.status ?? "unknown";
+      if (actual !== expected) {
+        findings.push(
+          failFinding(
+            "run.status",
+            `Run status ${actual} did not match expected ${expected}.`,
+            runEvidence(context.selectedRun),
+            expected,
+            actual
+          )
+        );
+      }
+      if (!allowIncomplete) {
+        const running = semanticEvents(context).filter((event) => event.status === "running");
+        if (running.length > 0) {
+          findings.push(
+            failFinding(
+              "run.status",
+              "Run contains incomplete running events.",
+              running.map((event) => eventEvidence(event)),
+              "no running events",
+              running.length
+            )
+          );
+        }
+      }
+      return findings;
     }
   };
 }
-function asLogical(event, extras) {
+function createRunDurationRule(options) {
   return {
-    ...cloneEvent(event),
-    sourceEventIds: Object.freeze([event.eventId]),
-    projection: {
-      paired: false,
-      absorbedEventIds: Object.freeze([]),
-      parentNormalized: extras?.parentNormalized === true,
-      ...{}
+    id: "run.duration",
+    category: "run",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const actual = context.selectedRun?.durationMs;
+      if (actual === void 0 || actual <= options.maxDurationMs) return [];
+      return [
+        failFinding(
+          "run.duration",
+          `Run duration ${actual}ms exceeded ${options.maxDurationMs}ms.`,
+          runEvidence(context.selectedRun),
+          { maxDurationMs: options.maxDurationMs },
+          actual
+        )
+      ];
     }
   };
 }
-function projectLogicalEvents(events) {
-  const diagnostics = [];
-  const byRun = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const list = byRun.get(event.runId) ?? [];
-    list.push(event);
-    byRun.set(event.runId, list);
-  }
-  const absorbedIds = /* @__PURE__ */ new Set();
-  const logicalByRawId = /* @__PURE__ */ new Map();
-  const stepIdToLogicalId = /* @__PURE__ */ new Map();
-  const logical = [];
-  const orderedRuns = [...byRun.keys()].sort((a, b) => a.localeCompare(b));
-  for (const runId of orderedRuns) {
-    const runEvents = byRun.get(runId) ?? [];
-    const starts = [];
-    const completes = [];
-    const others = [];
-    for (const event of runEvents) {
-      const legacy = legacyEvent(event);
-      if (legacy === "step_started" || legacy === "run_started" && event.status === "running") {
-        starts.push(event);
-      } else if (legacy === "step_completed" || legacy === "run_completed") {
-        completes.push(event);
-      } else {
-        others.push(event);
+function createToolUsageRule(options) {
+  return {
+    id: "tool.usage",
+    category: "tool",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const tools = toolInvocationEvents(context);
+      const names = tools.map(toolName);
+      const nameSet = new Set(names);
+      const findings = [];
+      for (const required of options.required ?? []) {
+        if (!nameSet.has(required)) {
+          findings.push(
+            failFinding("tool.usage", `Required tool ${required} did not appear.`, runEvidence(context.selectedRun), required, names)
+          );
+        }
       }
-    }
-    const usedCompletes = /* @__PURE__ */ new Set();
-    for (const start of starts) {
-      const stepId = stepIdOf(start);
-      let match;
-      if (legacyEvent(start) === "run_started") {
-        const candidates = completes.filter(
-          (c) => !usedCompletes.has(c.eventId) && legacyEvent(c) === "run_completed"
-        );
-        if (candidates.length > 1) {
-          diagnostics.push({
-            code: "AI_LOGICAL_PAIR_AMBIGUOUS",
-            message: `Multiple run_completed rows for run ${runId}; using first by eventId.`,
-            eventIds: candidates.map((c) => c.eventId)
-          });
-          candidates.sort((a, b) => a.eventId.localeCompare(b.eventId));
+      const forbidden = new Set(options.forbidden ?? []);
+      const allowed = options.allowed?.length ? new Set(options.allowed) : void 0;
+      for (const event of tools) {
+        const name = toolName(event);
+        if (forbidden.has(name)) {
+          findings.push(
+            failFinding("tool.usage", `Forbidden tool ${name} appeared.`, [eventEvidence(event)], "tool absent", name)
+          );
         }
-        match = candidates[0];
-      } else if (stepId) {
-        const candidates = completes.filter(
-          (c) => !usedCompletes.has(c.eventId) && legacyEvent(c) === "step_completed" && stepIdOf(c) === stepId
-        );
-        if (candidates.length > 1) {
-          diagnostics.push({
-            code: "AI_LOGICAL_PAIR_AMBIGUOUS",
-            message: `Multiple step_completed rows for stepId ${stepId}; using first by eventId.`,
-            eventIds: candidates.map((c) => c.eventId)
-          });
-          candidates.sort((a, b) => a.eventId.localeCompare(b.eventId));
+        if (allowed && !allowed.has(name)) {
+          findings.push(
+            failFinding("tool.usage", `Tool ${name} is not in the allowed tool set.`, [eventEvidence(event)], [...allowed].sort(), name)
+          );
         }
-        match = candidates[0];
       }
-      if (match) {
-        usedCompletes.add(match.eventId);
-        absorbedIds.add(match.eventId);
-        const paired = pairStartComplete(start, match);
-        logical.push(paired);
-        logicalByRawId.set(start.eventId, paired);
-        logicalByRawId.set(match.eventId, paired);
-        if (stepId) stepIdToLogicalId.set(`${runId}:${stepId}`, paired.eventId);
-      } else {
-        diagnostics.push({
-          code: "AI_LOGICAL_PAIR_UNMATCHED_START",
-          message: `No matching complete for start ${start.eventId}.`,
-          eventIds: [start.eventId]
-        });
-        const alone = asLogical(start);
-        logical.push(alone);
-        logicalByRawId.set(start.eventId, alone);
-        if (stepId) stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      if (options.minCount !== void 0 && tools.length < options.minCount) {
+        findings.push(
+          failFinding("tool.usage", `Tool count ${tools.length} was below minimum ${options.minCount}.`, runEvidence(context.selectedRun), { minCount: options.minCount }, tools.length)
+        );
       }
-    }
-    for (const complete of completes) {
-      if (usedCompletes.has(complete.eventId)) continue;
-      diagnostics.push({
-        code: "AI_LOGICAL_PAIR_UNMATCHED_COMPLETE",
-        message: `No matching start for complete ${complete.eventId}.`,
-        eventIds: [complete.eventId]
-      });
-      const alone = asLogical(complete);
-      logical.push(alone);
-      logicalByRawId.set(complete.eventId, alone);
-      const stepId = stepIdOf(complete);
-      if (stepId && !stepIdToLogicalId.has(`${runId}:${stepId}`)) {
-        stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      if (options.maxCount !== void 0 && tools.length > options.maxCount) {
+        findings.push(
+          failFinding("tool.usage", `Tool count ${tools.length} exceeded maximum ${options.maxCount}.`, tools.map((event) => eventEvidence(event)), { maxCount: options.maxCount }, tools.length)
+        );
       }
+      return findings;
     }
-    for (const event of others) {
-      const alone = asLogical(event);
-      logical.push(alone);
-      logicalByRawId.set(event.eventId, alone);
-      const stepId = stepIdOf(event);
-      if (stepId && !stepIdToLogicalId.has(`${runId}:${stepId}`)) {
-        stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+  };
+}
+function createLlmUsageRule(options) {
+  return {
+    id: "llm.usage",
+    category: "llm",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const llms = finishedEvents(context, "LLM");
+      const findings = [];
+      const allowedModels = options.allowedModels?.length ? new Set(options.allowedModels) : void 0;
+      const allowedProviders = options.allowedProviders?.length ? new Set(options.allowedProviders) : void 0;
+      const finishReasons = options.finishReasons?.length ? new Set(options.finishReasons) : void 0;
+      if (options.maxCalls !== void 0 && llms.length > options.maxCalls) {
+        findings.push(
+          failFinding(
+            "llm.usage",
+            `LLM call count ${llms.length} exceeded ${options.maxCalls}.`,
+            llms.map((event) => eventEvidence(event)),
+            { maxCalls: options.maxCalls },
+            llms.length
+          )
+        );
       }
-    }
-  }
-  const logicalById = new Map(logical.map((e) => [e.eventId, e]));
-  const normalized = [];
-  for (const event of logical) {
-    const originalParentId = event.parentId;
-    if (!originalParentId) {
-      normalized.push(event);
-      continue;
-    }
-    let nextParent = originalParentId;
-    let remapped = false;
-    const viaAbsorbed = logicalByRawId.get(originalParentId);
-    if (viaAbsorbed && viaAbsorbed.eventId !== originalParentId) {
-      nextParent = viaAbsorbed.eventId;
-      remapped = true;
-    } else if (!logicalById.has(originalParentId)) {
-      const viaStep = stepIdToLogicalId.get(`${event.runId}:${originalParentId}`);
-      if (viaStep) {
-        nextParent = viaStep;
-        remapped = true;
-      }
-    }
-    if (!remapped) {
-      if (originalParentId === event.eventId) {
-        diagnostics.push({
-          code: "AI_LOGICAL_SELF_PARENT_REMOVED",
-          message: formatProgrammaticDiagnostic(
-            "AI_TRACE_RELATIONSHIP_SELF_PARENT",
-            `Removed self-parent edge on ${event.eventId}.`
-          ),
-          eventIds: [event.eventId]
-        });
-        const { parentId: _drop, ...rest } = event;
-        normalized.push({
-          ...rest,
-          projection: {
-            ...event.projection,
-            parentNormalized: true,
-            originalParentId
-          }
-        });
-        continue;
-      }
-      if (!logicalById.has(originalParentId) && !logicalByRawId.has(originalParentId)) {
-        const mapping = event.attributes?.parentMapping;
-        const unresolved = mapping === "unresolved" || event.attributes?.parentUnresolved === true || event.attributes?.unresolvedParent === true || // LangGraph/framework scaffolding sentinel labels are not event ids.
-        /^LangGraph$/i.test(originalParentId) || originalParentId.startsWith("unresolved:");
-        if (!unresolved) {
-          diagnostics.push({
-            code: "AI_LOGICAL_PARENT_UNRESOLVED",
-            message: `Parent ${originalParentId} unresolved for ${event.eventId}.`,
-            eventIds: [event.eventId]
-          });
+      for (const event of llms) {
+        const model = llmModel(event);
+        const provider = llmProvider(event);
+        const finishReason = llmFinishReason(event);
+        if (allowedModels && (!model || !allowedModels.has(model))) {
+          findings.push(
+            failFinding("llm.usage", `LLM model ${model ?? "unknown"} is not allowed.`, [eventEvidence(event, "attributes.model")], [...allowedModels].sort(), model ?? "unknown")
+          );
+        }
+        if (allowedProviders && (!provider || !allowedProviders.has(provider))) {
+          findings.push(
+            failFinding("llm.usage", `LLM provider ${provider ?? "unknown"} is not allowed.`, [eventEvidence(event, "attributes.provider")], [...allowedProviders].sort(), provider ?? "unknown")
+          );
+        }
+        if (finishReasons && (!finishReason || !finishReasons.has(finishReason))) {
+          findings.push(
+            failFinding("llm.usage", `LLM finish reason ${finishReason ?? "unknown"} is not allowed.`, [eventEvidence(event, "attributes.finishReason")], [...finishReasons].sort(), finishReason ?? "unknown")
+          );
         }
       }
-      normalized.push(event);
-      continue;
-    }
-    if (nextParent === event.eventId) {
-      diagnostics.push({
-        code: "AI_LOGICAL_SELF_PARENT_REMOVED",
-        message: formatProgrammaticDiagnostic(
-          "AI_TRACE_RELATIONSHIP_SELF_PARENT",
-          `Removed self-parent edge on ${event.eventId} (was ${originalParentId}).`
-        ),
-        eventIds: [event.eventId]
-      });
-      const { parentId: _drop, ...rest } = event;
-      normalized.push({
-        ...rest,
-        projection: {
-          ...event.projection,
-          parentNormalized: true,
-          originalParentId
+      const tokenTotals = llms.reduce(
+        (totals, event) => ({
+          input: totals.input + (event.tokenUsage?.input ?? 0),
+          output: totals.output + (event.tokenUsage?.output ?? 0),
+          total: totals.total + (event.tokenUsage?.total ?? 0),
+          cached: totals.cached + (event.tokenUsage?.cached ?? 0)
+        }),
+        { input: 0, output: 0, total: 0, cached: 0 }
+      );
+      const tokenLimits = [
+        ["input", options.maxInputTokens],
+        ["output", options.maxOutputTokens],
+        ["total", options.maxTotalTokens],
+        ["cached", options.maxCachedTokens]
+      ];
+      for (const [key, limit] of tokenLimits) {
+        if (limit !== void 0 && tokenTotals[key] > limit) {
+          findings.push(
+            failFinding(
+              "llm.usage",
+              `LLM ${key} token count ${tokenTotals[key]} exceeded ${limit}.`,
+              llms.map((event) => eventEvidence(event, `tokenUsage.${key}`)),
+              { [`max${key[0].toUpperCase()}${key.slice(1)}Tokens`]: limit },
+              tokenTotals[key]
+            )
+          );
         }
-      });
-      continue;
-    }
-    diagnostics.push({
-      code: "AI_LOGICAL_PARENT_REMAPPED",
-      message: `Remapped parent ${originalParentId} \u2192 ${nextParent} for ${event.eventId}.`,
-      eventIds: [event.eventId]
-    });
-    normalized.push({
-      ...event,
-      parentId: nextParent,
-      projection: {
-        ...event.projection,
-        parentNormalized: true,
-        originalParentId
       }
-    });
-  }
-  const rawIndex = new Map(events.map((e, i) => [e.eventId, i]));
-  normalized.sort((a, b) => {
-    const ai = rawIndex.get(a.sourceEventIds[0]) ?? 0;
-    const bi = rawIndex.get(b.sourceEventIds[0]) ?? 0;
-    return ai - bi || a.eventId.localeCompare(b.eventId);
-  });
+      return findings;
+    }
+  };
+}
+function createObservedOutcomeRule(options = {}) {
+  const failOn = options.failOn ?? ["failed"];
+  const requireAny = options.requireAny === true;
   return {
-    logicalEvents: Object.freeze(normalized),
-    diagnostics: Object.freeze(diagnostics)
+    id: "outcome.status",
+    category: "run",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const outcomes = extractOutcomesFromPersistedEvents(context.events);
+      if (requireAny && outcomes.length === 0) {
+        return [
+          failFinding(
+            "outcome.status",
+            "Expected at least one observed outcome.",
+            runEvidence(context.selectedRun),
+            { requireAny: true, expected: "at least one observed outcome" },
+            { code: "outcome.missing", actual: 0 }
+          )
+        ];
+      }
+      const matching = outcomesMatchingStatus(outcomes, failOn);
+      if (matching.length === 0) return [];
+      return [
+        failFinding(
+          "outcome.status",
+          `Observed outcome count ${matching.length} matched [${failOn.join(", ")}].`,
+          matching.map((outcome) => ({
+            runId: outcome.runId,
+            eventId: outcome.outcomeId,
+            ...outcome.parentId !== void 0 ? { parentId: outcome.parentId } : {},
+            kind: "OUTCOME",
+            name: outcome.name,
+            status: outcome.status,
+            path: `outcome.${outcome.name}`
+          })),
+          { failOn },
+          matching.map((outcome) => ({
+            name: outcome.name,
+            status: outcome.status,
+            expectation: outcome.expectation
+          }))
+        )
+      ];
+    }
   };
 }
-function resolveCanonicalToolName(event) {
-  const attrs = event.attributes;
-  const direct = pickString(attrs, ["toolName", "tool"]);
-  if (direct) return direct;
-  const metadata = attrs?.metadata;
-  if (isRecord5(metadata)) {
-    const nested = pickString(metadata, ["toolName", "tool"]);
-    if (nested) return nested;
+function runTraceChecks(input, options = {}) {
+  const selected = resolveSelectedRun(input, options.runId);
+  if (selected.diagnostics.length > 0) {
+    return errorResult(input, selected.diagnostics, selected.run);
   }
-  for (const prefix of ["tool:", "function:", "mcp-tools:"]) {
-    if (event.name.startsWith(prefix)) return event.name.slice(prefix.length);
+  const rules = selectRules(options.rules ?? [], options.select);
+  if (rules.diagnostics.length > 0) {
+    return errorResult(input, rules.diagnostics, selected.run);
   }
-  return event.name;
-}
-function pickString(record, keys) {
-  if (!record) return void 0;
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "string" && value.trim() !== "") return value.trim();
+  if (rules.rules.length === 0) {
+    return errorResult(
+      input,
+      [
+        diagnostic(
+          "AI_CHECK_NO_RULES_EVALUATED",
+          "No trace check rules were evaluated. Configure at least one rule, contract, or CLI check option."
+        )
+      ],
+      selected.run
+    );
   }
-  return void 0;
-}
-
-// packages/core/src/checks/trace-facts.ts
-formatProgrammaticDiagnostic(
-  "AI_TRACE_FACTS_INPUT_NOT_NORMALIZED"
-);
-
-// packages/core/src/checks/contract.ts
-new Set(OBSERVED_OUTCOME_METHODS);
-
-// packages/core/src/checks/index.ts
-var SEVERITY_RANK = {
-  error: 0,
-  warning: 1,
-  info: 2
-};
-var STATUS_RANK = {
-  fail: 0,
-  warning: 1,
-  pass: 2
-};
-function compareStrings(a, b) {
-  return (a ?? "").localeCompare(b ?? "");
-}
-function diagnostic3(code, message, ruleId) {
-  return {
-    code,
-    message,
-    severity: "error",
-    ...ruleId ? { ruleId } : {}
-  };
-}
-function emptySummary() {
-  return {
-    passed: 0,
-    failed: 0,
-    warnings: 0,
-    errors: 0,
-    rulesEvaluated: 0
+  const facts = buildFacts(input, selected.run);
+  const context = {
+    ...facts,
+    ...selected.run ? { selectedRun: selected.run } : {},
+    ...input.sourceLabel ? { sourceLabel: input.sourceLabel } : {}
   };
-}
-function errorResult(input, diagnostics, selectedRun, ruleExecutions = []) {
-  return {
-    ok: false,
-    status: "error",
-    format: input.read.format,
-    ...selectedRun ? { runId: selectedRun.runId } : {},
-    summary: {
-      ...emptySummary(),
-      errors: diagnostics.filter((item) => item.severity === "error").length,
-      rulesEvaluated: ruleExecutions.length
-    },
-    findings: [],
-    diagnostics: [...diagnostics],
-    ruleExecutions: [...ruleExecutions]
-  };
-}
-function flattenNodes(nodes) {
-  return nodes.flatMap((node) => [node, ...flattenNodes(node.children)]);
-}
-function buildFacts(input, selectedRun) {
-  const scopedRuns = selectedRun ? [selectedRun] : input.read.runs;
-  const scopedRunIds = new Set(scopedRuns.map((run) => run.runId));
-  const scopedEvents = selectedRun === void 0 ? input.read.events : input.read.events.filter((event) => scopedRunIds.has(event.runId));
-  const nodes = flattenNodes(scopedRuns.flatMap((run) => run.children));
-  const nodesByEventId = /* @__PURE__ */ new Map();
-  const childrenByParentId = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    nodesByEventId.set(node.event.eventId, node);
-    const parentId = node.event.parentId;
-    if (parentId) {
-      const children = childrenByParentId.get(parentId) ?? [];
-      children.push(node);
-      childrenByParentId.set(parentId, children);
+  const diagnostics = [];
+  const findings = [];
+  const ruleExecutions = [];
+  for (const rule of rules.rules) {
+    try {
+      const ruleFindings = rule.evaluate(context).map((finding) => normalizeFinding(rule, finding));
+      findings.push(...ruleFindings);
+      ruleExecutions.push({
+        ruleId: rule.id,
+        category: rule.category,
+        status: classifyRuleExecution(ruleFindings, false),
+        findingCount: ruleFindings.length,
+        ...selected.run ? { runId: selected.run.runId } : {}
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      diagnostics.push(
+        diagnostic("AI_CHECK_INTERNAL_ERROR", `Rule ${rule.id} failed: ${message}`, rule.id)
+      );
+      ruleExecutions.push({
+        ruleId: rule.id,
+        category: rule.category,
+        status: "error",
+        findingCount: 0,
+        ...selected.run ? { runId: selected.run.runId } : {}
+      });
     }
   }
-  const projection = projectLogicalEvents(scopedEvents);
+  if (diagnostics.length > 0) {
+    return errorResult(input, diagnostics, selected.run, ruleExecutions);
+  }
+  const eventById = new Map(input.read.events.map((event) => [event.eventId, event]));
+  const sortedFindings = findings.sort(compareFindings(eventById));
+  const summary = summarize(sortedFindings, diagnostics, ruleExecutions.length);
+  const status = summary.failed > 0 ? "fail" : "pass";
   return {
+    ok: status === "pass",
+    status,
     format: input.read.format,
-    runs: Object.freeze([...input.read.runs]),
-    events: Object.freeze([...scopedEvents]),
-    logicalEvents: projection.logicalEvents,
-    logicalProjectionDiagnostics: projection.diagnostics,
-    readerWarnings: Object.freeze([...input.read.warnings]),
-    unsupportedFields: Object.freeze([...input.read.unsupportedFields]),
-    sourceFiles: Object.freeze([...input.read.sourceFiles]),
-    nodesByEventId,
-    childrenByParentId,
-    rootNodes: Object.freeze(scopedRuns.flatMap((run) => run.children))
+    ...selected.run ? { runId: selected.run.runId } : {},
+    summary,
+    findings: sortedFindings,
+    diagnostics,
+    ruleExecutions
   };
 }
-function resolveSelectedRun(input, runId) {
-  if (input.selectedRun) {
-    if (runId && input.selectedRun.runId !== runId) {
-      return {
-        diagnostics: [
-          diagnostic3(
-            "AI_CHECK_INVALID_ARGUMENTS",
-            `Selected run ${input.selectedRun.runId} does not match requested run ${runId}.`
-          )
-        ]
-      };
-    }
-    return { run: input.selectedRun, diagnostics: [] };
+
+// packages/core/src/checks/contract.ts
+new Set(OBSERVED_OUTCOME_METHODS);
+
+// packages/core/src/exporters/helpers.ts
+function sortKeysDeep(input) {
+  if (input === null || typeof input !== "object") return input;
+  if (Array.isArray(input)) return input.map(sortKeysDeep);
+  const o = input;
+  const out = {};
+  for (const k of Object.keys(o).sort()) {
+    out[k] = sortKeysDeep(o[k]);
   }
-  if (runId) {
-    const run = input.read.runs.find((candidate) => candidate.runId === runId);
-    if (!run) {
-      return {
-        diagnostics: [
-          diagnostic3("AI_CHECK_RUN_SELECTION_REQUIRED", `Run not found: ${runId}.`)
-        ]
-      };
-    }
-    return { run, diagnostics: [] };
+  return out;
+}
+function stableJson(value, pretty) {
+  const sorted = sortKeysDeep(value);
+  return JSON.stringify(sorted);
+}
+
+// packages/core/src/diff/comparable.ts
+function extractOutputPreview(meta) {
+  if (meta === void 0) return void 0;
+  if ("outputPreview" in meta) return meta.outputPreview;
+  if ("resultPreview" in meta) return meta.resultPreview;
+  return void 0;
+}
+function mapStepStatus(s) {
+  if (s === void 0) return "running";
+  return s;
+}
+function manualTraceEventsToComparableRun(events) {
+  const started = events.find((e) => e.event === "run_started");
+  if (!started || started.event !== "run_started") {
+    throw new Error("Invalid trace: missing run_started");
   }
-  if (input.read.runs.length === 1) {
-    return { run: input.read.runs[0], diagnostics: [] };
+  const rs = started;
+  const runId = rs.runId;
+  const completedAll = events.filter((e) => e.event === "run_completed");
+  const lastCompleted = completedAll[completedAll.length - 1];
+  let runStatus;
+  if (lastCompleted === void 0) runStatus = "running";
+  else runStatus = lastCompleted.status;
+  const durationMs = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const steps = /* @__PURE__ */ new Map();
+  let order = 0;
+  for (const e of events) {
+    if (e.event !== "step_started") continue;
+    const s = e;
+    const meta = s.metadata ? { ...s.metadata } : void 0;
+    steps.set(s.stepId, {
+      id: s.stepId,
+      parentId: s.parentId,
+      name: s.name,
+      type: s.type,
+      order: order++,
+      timestamp: s.timestamp,
+      metadata: meta
+    });
   }
-  if (input.read.runs.length === 0) {
-    return {
-      diagnostics: [
-        diagnostic3(
-          "AI_CHECK_RUN_SELECTION_REQUIRED",
-          formatProgrammaticDiagnostic(
-            "AI_TRACE_CONTRACT_RUN_SELECTION_REQUIRED",
-            "No runs are available for checks."
-          )
-        )
-      ]
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const acc = steps.get(e.stepId);
+    if (!acc) continue;
+    acc.status = e.status;
+    acc.durationMs = e.durationMs;
+    if (e.error?.message) acc.errorMsg = e.error.message;
+    const extra = e;
+    if (extra.metadata !== void 0 && typeof extra.metadata === "object") {
+      acc.metadata = { ...acc.metadata ?? {}, ...extra.metadata };
+    }
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  for (const acc of steps.values()) {
+    let meta = acc.metadata ? { ...acc.metadata } : void 0;
+    if (acc.parentId !== void 0 && !steps.has(acc.parentId)) {
+      meta = { ...meta ?? {}, agent_inspect_diff_parent_missing: true };
+    }
+    const outputPreview = extractOutputPreview(meta);
+    if (meta !== void 0 && ("outputPreview" in meta || "resultPreview" in meta)) {
+      delete meta.outputPreview;
+      delete meta.resultPreview;
+    }
+    const sc = {
+      id: acc.id,
+      name: acc.name,
+      type: acc.type,
+      status: mapStepStatus(acc.status),
+      durationMs: acc.durationMs,
+      error: acc.errorMsg,
+      metadata: meta && Object.keys(meta).length > 0 ? meta : void 0,
+      outputPreview,
+      children: []
     };
+    nodes.set(acc.id, sc);
   }
-  return {
-    diagnostics: [
-      diagnostic3(
-        "AI_CHECK_RUN_SELECTION_REQUIRED",
-        formatProgrammaticDiagnostic("AI_TRACE_CONTRACT_RUN_SELECTION_REQUIRED")
-      )
-    ]
+  const roots = [];
+  const sortByOrder = (a, b) => {
+    const oa = steps.get(a.id)?.order ?? 0;
+    const ob = steps.get(b.id)?.order ?? 0;
+    return oa - ob;
   };
-}
-function selectRules(rules, selectedIds) {
-  const diagnostics = [];
-  const byId = /* @__PURE__ */ new Map();
-  for (const rule of rules) {
-    if (byId.has(rule.id)) {
-      diagnostics.push(
-        diagnostic3("AI_CHECK_INVALID_CONFIG", `Duplicate trace check rule id: ${rule.id}.`, rule.id)
-      );
-      continue;
+  for (const acc of steps.values()) {
+    const node = nodes.get(acc.id);
+    if (acc.parentId !== void 0 && nodes.has(acc.parentId)) {
+      nodes.get(acc.parentId).children.push(node);
+    } else {
+      roots.push(node);
     }
-    byId.set(rule.id, rule);
   }
-  if (selectedIds && selectedIds.length > 0) {
-    const selected = new Set(selectedIds);
-    for (const id of selected) {
-      if (!byId.has(id)) {
-        diagnostics.push(
-          diagnostic3("AI_CHECK_INVALID_CONFIG", `Unknown trace check rule id: ${id}.`, id)
-        );
-      }
-    }
-    return {
-      rules: [...byId.values()].filter((rule) => selected.has(rule.id)).sort(compareRules),
-      diagnostics
-    };
+  roots.sort(sortByOrder);
+  for (const n of nodes.values()) {
+    n.children.sort(sortByOrder);
   }
-  return { rules: [...byId.values()].sort(compareRules), diagnostics };
+  return {
+    runId,
+    name: rs.name,
+    status: runStatus,
+    durationMs,
+    steps: roots
+  };
 }
-function compareRules(a, b) {
-  return a.id.localeCompare(b.id);
+
+// packages/core/src/diff/engine.ts
+var DEFAULT_THRESHOLD_MS = 0;
+function pathSeg(step, index) {
+  return { index, name: step.name, stepId: step.id };
 }
-function eventTimestamp(finding, eventById) {
-  const eventId = finding.evidence[0]?.eventId;
-  return eventId ? eventById.get(eventId)?.timestamp ?? "" : "";
+function buildPath(segments) {
+  return { path: [...segments] };
 }
-function compareFindings(eventById) {
-  return (a, b) => {
-    if (SEVERITY_RANK[a.severity] !== SEVERITY_RANK[b.severity]) {
-      return SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity];
+function pairSteps(left, right) {
+  const usedRight = /* @__PURE__ */ new Set();
+  const pairs = [];
+  for (let i = 0; i < left.length; i++) {
+    const L = left[i];
+    let R = right.find((r) => !usedRight.has(r.id) && r.id === L.id);
+    if (R === void 0 && i < right.length && !usedRight.has(right[i].id)) {
+      const cand = right[i];
+      if (cand.name === L.name && (cand.type ?? "") === (L.type ?? "")) {
+        R = cand;
+      }
     }
-    const byRule = a.ruleId.localeCompare(b.ruleId);
-    if (byRule !== 0) return byRule;
-    if (STATUS_RANK[a.status] !== STATUS_RANK[b.status]) {
-      return STATUS_RANK[a.status] - STATUS_RANK[b.status];
+    if (R === void 0) {
+      R = right.find(
+        (r) => !usedRight.has(r.id) && r.name === L.name && (r.type ?? "") === (L.type ?? "")
+      );
+    }
+    if (R !== void 0) {
+      usedRight.add(R.id);
+      pairs.push([L, R]);
+    } else {
+      pairs.push([L, void 0]);
     }
-    const byRun = compareStrings(a.evidence[0]?.runId, b.evidence[0]?.runId);
-    if (byRun !== 0) return byRun;
-    const byTime = eventTimestamp(a, eventById).localeCompare(eventTimestamp(b, eventById));
-    if (byTime !== 0) return byTime;
-    const byEvent = compareStrings(a.evidence[0]?.eventId, b.evidence[0]?.eventId);
-    if (byEvent !== 0) return byEvent;
-    return compareStrings(a.evidence[0]?.path, b.evidence[0]?.path);
-  };
-}
-function normalizeFinding(rule, finding) {
-  return {
-    ruleId: finding.ruleId || rule.id,
-    severity: finding.severity ?? rule.defaultSeverity,
-    status: finding.status,
-    message: finding.message,
-    ...finding.expected !== void 0 ? { expected: finding.expected } : {},
-    ...finding.actual !== void 0 ? { actual: finding.actual } : {},
-    evidence: [...finding.evidence ?? []],
-    ...finding.category !== void 0 ? { category: finding.category } : {},
-    ...finding.confidence !== void 0 ? { confidence: finding.confidence } : {},
-    ...finding.detector !== void 0 ? { detector: finding.detector } : {},
-    ...finding.action !== void 0 ? { action: finding.action } : {}
-  };
-}
-function summarize(findings, diagnostics, rulesEvaluated) {
-  return {
-    passed: findings.filter((finding) => finding.status === "pass").length,
-    failed: findings.filter(
-      (finding) => finding.status === "fail" && finding.severity === "error"
-    ).length,
-    warnings: findings.filter(
-      (finding) => finding.status === "warning" || finding.severity === "warning"
-    ).length,
-    errors: diagnostics.filter((item) => item.severity === "error").length,
-    rulesEvaluated
-  };
-}
-function classifyRuleExecution(findings, threw) {
-  if (findings.some((finding) => finding.status === "fail" && finding.severity === "error")) {
-    return "fail";
   }
-  if (findings.some(
-    (finding) => finding.status === "warning" || finding.severity === "warning"
-  )) {
-    return "warning";
+  for (const R of right) {
+    if (!usedRight.has(R.id)) {
+      pairs.push([void 0, R]);
+    }
   }
-  return "pass";
+  return pairs;
 }
-function stringAttr(event, keys) {
-  for (const key of keys) {
-    const value = event.attributes?.[key];
-    if (typeof value === "string" && value.trim() !== "") return value;
+function compareLeafSteps(L, R, segments, opts, out) {
+  const path18 = buildPath(segments);
+  if (L.name !== R.name) {
+    out.push({
+      kind: "structure",
+      severity: "warning",
+      message: "Step name differs",
+      path: path18,
+      left: L.name,
+      right: R.name
+    });
   }
-  return void 0;
-}
-function metadataStringAttr(event, keys) {
-  const metadata = event.attributes?.metadata;
-  if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
-    return void 0;
+  if ((L.type ?? "") !== (R.type ?? "")) {
+    out.push({
+      kind: "step-type",
+      severity: "warning",
+      message: "Step type differs",
+      path: path18,
+      left: L.type,
+      right: R.type
+    });
   }
-  const record = metadata;
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "string" && value.trim() !== "") return value;
+  if ((L.status ?? "") !== (R.status ?? "")) {
+    out.push({
+      kind: "step-status",
+      severity: "warning",
+      message: "Step status differs",
+      path: path18,
+      left: L.status,
+      right: R.status
+    });
+  }
+  const le = L.error ?? "";
+  const re = R.error ?? "";
+  if (le !== re) {
+    out.push({
+      kind: "error",
+      severity: "error",
+      message: "Step error message differs",
+      path: path18,
+      left: le || void 0,
+      right: re || void 0
+    });
+  }
+  if (!opts.ignoreDuration) {
+    const ld = L.durationMs;
+    const rd = R.durationMs;
+    const th = opts.durationThresholdMs;
+    let differs = false;
+    if (ld === void 0 && rd === void 0) differs = false;
+    else if (ld === void 0 || rd === void 0) differs = true;
+    else differs = Math.abs(ld - rd) > th;
+    if (differs) {
+      out.push({
+        kind: "duration",
+        severity: "info",
+        message: "Step duration differs",
+        path: path18,
+        left: ld,
+        right: rd
+      });
+    }
+  }
+  const lm = stableJson(L.metadata ?? {});
+  const rm2 = stableJson(R.metadata ?? {});
+  if (lm !== rm2) {
+    out.push({
+      kind: "metadata",
+      severity: "info",
+      message: "Step metadata differs",
+      path: path18,
+      left: L.metadata,
+      right: R.metadata
+    });
+  }
+  const lo = stableJson(L.outputPreview ?? null);
+  const ro = stableJson(R.outputPreview ?? null);
+  if (lo !== ro) {
+    out.push({
+      kind: "output",
+      severity: "info",
+      message: "Output preview differs",
+      path: path18,
+      left: L.outputPreview,
+      right: R.outputPreview
+    });
   }
-  return void 0;
 }
-function stripPrefix(name, prefixes) {
-  for (const prefix of prefixes) {
-    if (name.startsWith(prefix)) return name.slice(prefix.length);
+function compareRecursive(L, R, segments, opts, out) {
+  compareLeafSteps(L, R, segments, opts, out);
+  const pairs = pairSteps(L.children, R.children);
+  let ci = 0;
+  for (const [lch, rch] of pairs) {
+    if (lch !== void 0 && rch !== void 0) {
+      compareRecursive(lch, rch, [...segments, pathSeg(lch, ci)], opts, out);
+    } else if (lch !== void 0) {
+      out.push({
+        kind: "step-removed",
+        severity: "warning",
+        message: `Step only in left run: ${lch.name}`,
+        path: buildPath([...segments, pathSeg(lch, ci)]),
+        left: lch.id,
+        right: void 0
+      });
+    } else if (rch !== void 0) {
+      out.push({
+        kind: "step-added",
+        severity: "warning",
+        message: `Step only in right run: ${rch.name}`,
+        path: buildPath([...segments, pathSeg(rch, ci)]),
+        left: void 0,
+        right: rch.id
+      });
+    }
+    ci += 1;
   }
-  return name;
 }
-function eventEvidence(event, path18) {
+function mergeDiffDefaults(options) {
   return {
-    runId: event.runId,
-    eventId: event.eventId,
-    parentId: event.parentId,
-    traceId: event.trace?.traceId,
-    spanId: event.trace?.spanId,
-    kind: event.kind,
-    name: event.name,
-    status: event.status,
-    ...path18 ? { path: path18 } : {}
+    ignoreDuration: false,
+    durationThresholdMs: DEFAULT_THRESHOLD_MS,
+    focus: "all",
+    check: "all"
   };
 }
-function runEvidence(run) {
-  return run ? [{ runId: run.runId, name: run.name, status: run.status }] : [];
+function kindMatchesFilter(kind, merged) {
+  return true;
 }
-function failFinding(ruleId, message, evidence, expected, actual, meta) {
-  return {
-    ruleId,
-    severity: meta?.severity ?? "error",
-    status: meta?.status ?? "fail",
-    message,
-    ...expected !== void 0 ? { expected } : {},
-    ...actual !== void 0 ? { actual } : {},
-    evidence: [...evidence],
-    ...{},
-    ...{},
-    ...{},
-    ...{}
+function diffRuns(left, right, options) {
+  const merged = mergeDiffDefaults();
+  const opts = {
+    ignoreDuration: merged.ignoreDuration,
+    durationThresholdMs: merged.durationThresholdMs
   };
-}
-function toolName(event) {
-  return resolveCanonicalToolName(event);
-}
-function semanticEvents(context) {
-  return context.logicalEvents ?? context.events;
-}
-function llmModel(event) {
-  const keys = ["model", "modelId", "responseModelId", "modelName", "model_name"];
-  return stringAttr(event, keys) ?? metadataStringAttr(event, keys) ?? stripPrefix(event.name, ["llm:", "generation:", "transcription:", "speech:"]);
-}
-function llmProvider(event) {
-  const keys = ["provider", "providerName", "provider_name"];
-  return stringAttr(event, keys) ?? metadataStringAttr(event, keys);
-}
-function llmFinishReason(event) {
-  const keys = ["finishReason", "rawFinishReason", "finish_reason"];
-  return stringAttr(event, keys) ?? metadataStringAttr(event, keys);
-}
-function finishedEvents(context, kind) {
-  return semanticEvents(context).filter(
-    (event) => (event.kind === kind) && event.status !== "running"
-  );
-}
-function toolInvocationEvents(context) {
-  return semanticEvents(context).filter((event) => event.kind === "TOOL");
-}
-function createRunStatusRule(options = {}) {
-  const expected = options.expected ?? "ok";
-  const allowIncomplete = options.allowIncomplete === true;
-  return {
-    id: "run.status",
-    category: "run",
-    defaultSeverity: "error",
-    evaluate(context) {
-      const findings = [];
-      const actual = context.selectedRun?.status ?? "unknown";
-      if (actual !== expected) {
-        findings.push(
-          failFinding(
-            "run.status",
-            `Run status ${actual} did not match expected ${expected}.`,
-            runEvidence(context.selectedRun),
-            expected,
-            actual
-          )
-        );
-      }
-      if (!allowIncomplete) {
-        const running = semanticEvents(context).filter((event) => event.status === "running");
-        if (running.length > 0) {
-          findings.push(
-            failFinding(
-              "run.status",
-              "Run contains incomplete running events.",
-              running.map((event) => eventEvidence(event)),
-              "no running events",
-              running.length
-            )
-          );
-        }
-      }
-      return findings;
+  const raw = [];
+  if ((left.status ?? "") !== (right.status ?? "")) {
+    raw.push({
+      kind: "run-status",
+      severity: "warning",
+      message: "Run completion status differs",
+      left: left.status,
+      right: right.status
+    });
+  }
+  {
+    const ld = left.durationMs;
+    const rd = right.durationMs;
+    const th = merged.durationThresholdMs;
+    let differs = false;
+    if (ld === void 0 && rd === void 0) differs = false;
+    else if (ld === void 0 || rd === void 0) differs = true;
+    else differs = Math.abs(ld - rd) > th;
+    if (differs) {
+      raw.push({
+        kind: "duration",
+        severity: "info",
+        message: "Run duration differs",
+        left: ld,
+        right: rd
+      });
     }
-  };
-}
-function createRunDurationRule(options) {
-  return {
-    id: "run.duration",
-    category: "run",
-    defaultSeverity: "error",
-    evaluate(context) {
-      const actual = context.selectedRun?.durationMs;
-      if (actual === void 0 || actual <= options.maxDurationMs) return [];
-      return [
-        failFinding(
-          "run.duration",
-          `Run duration ${actual}ms exceeded ${options.maxDurationMs}ms.`,
-          runEvidence(context.selectedRun),
-          { maxDurationMs: options.maxDurationMs },
-          actual
-        )
-      ];
+  }
+  const pairs = pairSteps(left.steps, right.steps);
+  let idx = 0;
+  for (const [ls, rs] of pairs) {
+    if (ls !== void 0 && rs !== void 0) {
+      compareRecursive(ls, rs, [pathSeg(ls, idx)], opts, raw);
+      idx += 1;
+    } else if (ls !== void 0) {
+      raw.push({
+        kind: "step-removed",
+        severity: "warning",
+        message: `Step only in left run: ${ls.name}`,
+        path: buildPath([pathSeg(ls, idx)]),
+        left: ls.id,
+        right: void 0
+      });
+      idx += 1;
+    } else if (rs !== void 0) {
+      raw.push({
+        kind: "step-added",
+        severity: "warning",
+        message: `Step only in right run: ${rs.name}`,
+        path: buildPath([pathSeg(rs, idx)]),
+        left: void 0,
+        right: rs.id
+      });
+      idx += 1;
     }
+  }
+  const differences = raw.filter((d) => kindMatchesFilter(d.kind));
+  let errors = 0;
+  let warnings = 0;
+  let info = 0;
+  for (const d of differences) {
+    if (d.severity === "error") errors += 1;
+    else if (d.severity === "warning") warnings += 1;
+    else info += 1;
+  }
+  const firstVisible = differences[0];
+  const firstDivergence = firstVisible !== void 0 ? {
+    kind: "first-divergence",
+    severity: firstVisible.severity,
+    message: `First divergence: ${firstVisible.message}`,
+    path: firstVisible.path,
+    left: firstVisible.left,
+    right: firstVisible.right
+  } : void 0;
+  const summary = {
+    leftRunId: left.runId,
+    rightRunId: right.runId,
+    totalDifferences: differences.length,
+    errors,
+    warnings,
+    info,
+    firstDivergence
   };
+  return { summary, differences };
 }
-function createToolUsageRule(options) {
-  return {
-    id: "tool.usage",
-    category: "tool",
-    defaultSeverity: "error",
-    evaluate(context) {
-      const tools = toolInvocationEvents(context);
-      const names = tools.map(toolName);
-      const nameSet = new Set(names);
-      const findings = [];
-      for (const required of options.required ?? []) {
-        if (!nameSet.has(required)) {
-          findings.push(
-            failFinding("tool.usage", `Required tool ${required} did not appear.`, runEvidence(context.selectedRun), required, names)
-          );
-        }
-      }
-      const forbidden = new Set(options.forbidden ?? []);
-      const allowed = options.allowed?.length ? new Set(options.allowed) : void 0;
-      for (const event of tools) {
-        const name = toolName(event);
-        if (forbidden.has(name)) {
-          findings.push(
-            failFinding("tool.usage", `Forbidden tool ${name} appeared.`, [eventEvidence(event)], "tool absent", name)
-          );
-        }
-        if (allowed && !allowed.has(name)) {
-          findings.push(
-            failFinding("tool.usage", `Tool ${name} is not in the allowed tool set.`, [eventEvidence(event)], [...allowed].sort(), name)
-          );
-        }
-      }
-      if (options.minCount !== void 0 && tools.length < options.minCount) {
-        findings.push(
-          failFinding("tool.usage", `Tool count ${tools.length} was below minimum ${options.minCount}.`, runEvidence(context.selectedRun), { minCount: options.minCount }, tools.length)
-        );
-      }
-      if (options.maxCount !== void 0 && tools.length > options.maxCount) {
-        findings.push(
-          failFinding("tool.usage", `Tool count ${tools.length} exceeded maximum ${options.maxCount}.`, tools.map((event) => eventEvidence(event)), { maxCount: options.maxCount }, tools.length)
-        );
-      }
-      return findings;
+
+// packages/core/src/evidence/zip.ts
+(() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n += 1) {
+    let c = n;
+    for (let k = 0; k < 8; k += 1) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
     }
-  };
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+
+// packages/core/src/suite/types.ts
+var DEFAULT_SUITE_CONFIG_NAMES = [
+  "agent-inspect.suite.json",
+  "agent-inspect.suite.js",
+  "agent-inspect.suite.mjs",
+  "agent-inspect.suite.cjs"
+];
+function diagnostic2(code, message, severity = "error", caseId) {
+  return { code, message, severity, ...{} };
 }
-function createLlmUsageRule(options) {
-  return {
-    id: "llm.usage",
-    category: "llm",
-    defaultSeverity: "error",
-    evaluate(context) {
-      const llms = finishedEvents(context, "LLM");
-      const findings = [];
-      const allowedModels = options.allowedModels?.length ? new Set(options.allowedModels) : void 0;
-      const allowedProviders = options.allowedProviders?.length ? new Set(options.allowedProviders) : void 0;
-      const finishReasons = options.finishReasons?.length ? new Set(options.finishReasons) : void 0;
-      if (options.maxCalls !== void 0 && llms.length > options.maxCalls) {
-        findings.push(
-          failFinding(
-            "llm.usage",
-            `LLM call count ${llms.length} exceeded ${options.maxCalls}.`,
-            llms.map((event) => eventEvidence(event)),
-            { maxCalls: options.maxCalls },
-            llms.length
-          )
-        );
-      }
-      for (const event of llms) {
-        const model = llmModel(event);
-        const provider = llmProvider(event);
-        const finishReason = llmFinishReason(event);
-        if (allowedModels && (!model || !allowedModels.has(model))) {
-          findings.push(
-            failFinding("llm.usage", `LLM model ${model ?? "unknown"} is not allowed.`, [eventEvidence(event, "attributes.model")], [...allowedModels].sort(), model ?? "unknown")
-          );
-        }
-        if (allowedProviders && (!provider || !allowedProviders.has(provider))) {
-          findings.push(
-            failFinding("llm.usage", `LLM provider ${provider ?? "unknown"} is not allowed.`, [eventEvidence(event, "attributes.provider")], [...allowedProviders].sort(), provider ?? "unknown")
-          );
-        }
-        if (finishReasons && (!finishReason || !finishReasons.has(finishReason))) {
-          findings.push(
-            failFinding("llm.usage", `LLM finish reason ${finishReason ?? "unknown"} is not allowed.`, [eventEvidence(event, "attributes.finishReason")], [...finishReasons].sort(), finishReason ?? "unknown")
-          );
-        }
-      }
-      const tokenTotals = llms.reduce(
-        (totals, event) => ({
-          input: totals.input + (event.tokenUsage?.input ?? 0),
-          output: totals.output + (event.tokenUsage?.output ?? 0),
-          total: totals.total + (event.tokenUsage?.total ?? 0),
-          cached: totals.cached + (event.tokenUsage?.cached ?? 0)
-        }),
-        { input: 0, output: 0, total: 0, cached: 0 }
-      );
-      const tokenLimits = [
-        ["input", options.maxInputTokens],
-        ["output", options.maxOutputTokens],
-        ["total", options.maxTotalTokens],
-        ["cached", options.maxCachedTokens]
-      ];
-      for (const [key, limit] of tokenLimits) {
-        if (limit !== void 0 && tokenTotals[key] > limit) {
-          findings.push(
-            failFinding(
-              "llm.usage",
-              `LLM ${key} token count ${tokenTotals[key]} exceeded ${limit}.`,
-              llms.map((event) => eventEvidence(event, `tokenUsage.${key}`)),
-              { [`max${key[0].toUpperCase()}${key.slice(1)}Tokens`]: limit },
-              tokenTotals[key]
-            )
-          );
-        }
-      }
-      return findings;
-    }
-  };
+function asString(value, label) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  return value.trim();
 }
-function createObservedOutcomeRule(options = {}) {
-  const failOn = options.failOn ?? ["failed"];
-  const requireAny = options.requireAny === true;
-  return {
-    id: "outcome.status",
-    category: "run",
-    defaultSeverity: "error",
-    evaluate(context) {
-      const outcomes = extractOutcomesFromPersistedEvents(context.events);
-      if (requireAny && outcomes.length === 0) {
-        return [
-          failFinding(
-            "outcome.status",
-            "Expected at least one observed outcome.",
-            runEvidence(context.selectedRun),
-            { requireAny: true, expected: "at least one observed outcome" },
-            { code: "outcome.missing", actual: 0 }
-          )
-        ];
-      }
-      const matching = outcomesMatchingStatus(outcomes, failOn);
-      if (matching.length === 0) return [];
-      return [
-        failFinding(
-          "outcome.status",
-          `Observed outcome count ${matching.length} matched [${failOn.join(", ")}].`,
-          matching.map((outcome) => ({
-            runId: outcome.runId,
-            eventId: outcome.outcomeId,
-            ...outcome.parentId !== void 0 ? { parentId: outcome.parentId } : {},
-            kind: "OUTCOME",
-            name: outcome.name,
-            status: outcome.status,
-            path: `outcome.${outcome.name}`
-          })),
-          { failOn },
-          matching.map((outcome) => ({
-            name: outcome.name,
-            status: outcome.status,
-            expectation: outcome.expectation
-          }))
-        )
-      ];
+function asStringArray(value, label) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${label} must be an array of strings.`);
+  }
+  return value;
+}
+function asPositiveNumber(value, label) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative number.`);
+  }
+  return value;
+}
+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.`)
+    );
+    return { diagnostics };
+  }
+  const raw = value;
+  try {
+    const id = asString(raw.id, `cases[${index}].id`);
+    if (id === void 0) {
+      diagnostics.push(
+        diagnostic2("AI_SUITE_CONFIG_INVALID", `cases[${index}].id is required.`)
+      );
+      return { diagnostics };
     }
-  };
+    const trace = asString(raw.trace, `cases[${index}].trace`);
+    const runId = asString(raw.runId, `cases[${index}].runId`);
+    const input = asString(raw.input, `cases[${index}].input`);
+    return {
+      caseConfig: {
+        id,
+        ...trace !== void 0 ? { trace } : {},
+        ...runId !== void 0 ? { runId } : {},
+        ...input !== void 0 ? { input } : {},
+        ...asStringArray(raw.requireTools, `cases[${index}].requireTools`) !== void 0 ? { requireTools: asStringArray(raw.requireTools, `cases[${index}].requireTools`) } : {},
+        ...asStringArray(raw.forbidTools, `cases[${index}].forbidTools`) !== void 0 ? { forbidTools: asStringArray(raw.forbidTools, `cases[${index}].forbidTools`) } : {},
+        ...asPositiveNumber(raw.maxDurationMs, `cases[${index}].maxDurationMs`) !== void 0 ? {
+          maxDurationMs: asPositiveNumber(
+            raw.maxDurationMs,
+            `cases[${index}].maxDurationMs`
+          )
+        } : {},
+        ...asStringArray(
+          raw.expectedObservations,
+          `cases[${index}].expectedObservations`
+        ) !== void 0 ? {
+          expectedObservations: asStringArray(
+            raw.expectedObservations,
+            `cases[${index}].expectedObservations`
+          )
+        } : {}
+      },
+      diagnostics
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    diagnostics.push(diagnostic2("AI_SUITE_CONFIG_INVALID", message));
+    return { diagnostics };
+  }
 }
-function runTraceChecks(input, options = {}) {
-  const selected = resolveSelectedRun(input, options.runId);
-  if (selected.diagnostics.length > 0) {
-    return errorResult(input, selected.diagnostics, selected.run);
+function normalizeSuiteConfig(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("Suite config must export an object.");
   }
-  const rules = selectRules(options.rules ?? [], options.select);
-  if (rules.diagnostics.length > 0) {
-    return errorResult(input, rules.diagnostics, selected.run);
+  const raw = value;
+  const name = asString(raw.name, "name");
+  const traces = asString(raw.traces, "traces");
+  if (name === void 0) throw new Error("name is required.");
+  if (traces === void 0) throw new Error("traces is required.");
+  if (!Array.isArray(raw.cases) || raw.cases.length === 0) {
+    throw new Error("cases must be a non-empty array.");
   }
-  if (rules.rules.length === 0) {
-    return errorResult(
-      input,
-      [
-        diagnostic3(
-          "AI_CHECK_NO_RULES_EVALUATED",
-          "No trace check rules were evaluated. Configure at least one rule, contract, or CLI check option."
-        )
-      ],
-      selected.run
+  const cases = [];
+  for (let index = 0; index < raw.cases.length; index += 1) {
+    const { caseConfig, diagnostics } = validateCaseConfig(raw.cases[index], index);
+    if (diagnostics.length > 0) {
+      throw new Error(diagnostics.map((item) => item.message).join("; "));
+    }
+    if (caseConfig !== void 0) cases.push(caseConfig);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const suiteCase of cases) {
+    if (ids.has(suiteCase.id)) {
+      throw new Error(`Duplicate case id "${suiteCase.id}".`);
+    }
+    ids.add(suiteCase.id);
+  }
+  const redactionProfile = raw.redactionProfile === "local" || raw.redactionProfile === "share" || raw.redactionProfile === "strict" ? raw.redactionProfile : void 0;
+  if (raw.redactionProfile !== void 0 && redactionProfile === void 0) {
+    throw new Error('redactionProfile must be "local", "share", or "strict".');
+  }
+  const config = { name, traces, cases };
+  if (raw.checks !== void 0) {
+    if (typeof raw.checks !== "object" || Array.isArray(raw.checks)) {
+      throw new Error("checks must be an object.");
+    }
+    config.checks = raw.checks;
+  }
+  if (raw.eval !== void 0) {
+    if (typeof raw.eval !== "object" || Array.isArray(raw.eval)) {
+      throw new Error("eval must be an object.");
+    }
+    config.eval = raw.eval;
+  }
+  if (raw.artifacts !== void 0) {
+    if (typeof raw.artifacts !== "object" || Array.isArray(raw.artifacts)) {
+      throw new Error("artifacts must be an object.");
+    }
+    const outputDir = asString(
+      raw.artifacts.outputDir,
+      "artifacts.outputDir"
     );
+    config.artifacts = outputDir !== void 0 ? { outputDir } : {};
   }
-  const facts = buildFacts(input, selected.run);
-  const context = {
-    ...facts,
-    ...selected.run ? { selectedRun: selected.run } : {},
-    ...input.sourceLabel ? { sourceLabel: input.sourceLabel } : {}
-  };
-  const diagnostics = [];
-  const findings = [];
-  const ruleExecutions = [];
-  for (const rule of rules.rules) {
-    try {
-      const ruleFindings = rule.evaluate(context).map((finding) => normalizeFinding(rule, finding));
-      findings.push(...ruleFindings);
-      ruleExecutions.push({
-        ruleId: rule.id,
-        category: rule.category,
-        status: classifyRuleExecution(ruleFindings, false),
-        findingCount: ruleFindings.length,
-        ...selected.run ? { runId: selected.run.runId } : {}
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      diagnostics.push(
-        diagnostic3("AI_CHECK_INTERNAL_ERROR", `Rule ${rule.id} failed: ${message}`, rule.id)
-      );
-      ruleExecutions.push({
-        ruleId: rule.id,
-        category: rule.category,
-        status: "error",
-        findingCount: 0,
-        ...selected.run ? { runId: selected.run.runId } : {}
-      });
+  if (raw.baseline !== void 0) {
+    const baseline = asString(raw.baseline, "baseline");
+    if (baseline !== void 0) config.baseline = baseline;
+  }
+  if (raw.candidate !== void 0) {
+    const candidate = asString(raw.candidate, "candidate");
+    if (candidate !== void 0) config.candidate = candidate;
+  }
+  if (redactionProfile !== void 0) config.redactionProfile = redactionProfile;
+  return config;
+}
+
+// packages/core/src/suite/load.ts
+var CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".js", ".mjs", ".cjs"]);
+var TS_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts"]);
+function diagnostic3(code, message) {
+  return { code, message, severity: "error" };
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveSuiteConfigPath(options = {}) {
+  const cwd = path15.resolve(options.cwd ?? process.cwd());
+  if (options.configPath !== void 0 && options.configPath.trim() !== "") {
+    return path15.resolve(cwd, options.configPath.trim());
+  }
+  for (const name of DEFAULT_SUITE_CONFIG_NAMES) {
+    const candidate = path15.join(cwd, name);
+    if (await fileExists(candidate)) return candidate;
+  }
+  throw new Error(
+    `No suite config found. Create one with \`agent-inspect suite init\` or pass --config.`
+  );
+}
+async function loadSuiteConfig(options = {}) {
+  let configPath;
+  try {
+    configPath = await resolveSuiteConfigPath(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)]
+    });
+  }
+  const extension = path15.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)]
+    });
+  }
+  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)]
+    });
+  }
+  try {
+    let raw;
+    if (extension === ".json") {
+      raw = JSON.parse(await readFile(configPath, "utf-8"));
+    } else {
+      const mod = await import(pathToFileURL(configPath).href);
+      raw = "default" in mod ? mod.default : mod;
     }
+    const config = normalizeSuiteConfig(raw);
+    return {
+      config,
+      configPath,
+      configDir: path15.dirname(configPath)
+    };
+  } 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)]
+    });
   }
-  if (diagnostics.length > 0) {
-    return errorResult(input, diagnostics, selected.run, ruleExecutions);
+}
+async function exists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveSuiteCaseTrace(suiteCase, options) {
+  if (suiteCase.trace !== void 0) {
+    const tracePath = path15.resolve(options.configDir, suiteCase.trace);
+    if (await exists(tracePath)) {
+      return { caseId: suiteCase.id, tracePath, missing: false };
+    }
+    return {
+      caseId: suiteCase.id,
+      tracePath,
+      missing: true,
+      reason: `trace file not found: ${suiteCase.trace}`
+    };
+  }
+  const runKey = suiteCase.runId ?? suiteCase.id;
+  const directPath = getTraceFilePath(runKey, options.tracesDir);
+  if (await exists(directPath)) {
+    return { caseId: suiteCase.id, tracePath: directPath, runId: runKey, missing: false };
+  }
+  const nestedPath = path15.join(options.tracesDir, `${path15.basename(runKey)}.jsonl`);
+  if (await exists(nestedPath)) {
+    return { caseId: suiteCase.id, tracePath: nestedPath, runId: runKey, missing: false };
   }
-  const eventById = new Map(input.read.events.map((event) => [event.eventId, event]));
-  const sortedFindings = findings.sort(compareFindings(eventById));
-  const summary = summarize(sortedFindings, diagnostics, ruleExecutions.length);
-  const status = summary.failed > 0 ? "fail" : "pass";
   return {
-    ok: status === "pass",
-    status,
-    format: input.read.format,
-    ...selected.run ? { runId: selected.run.runId } : {},
-    summary,
-    findings: sortedFindings,
-    diagnostics,
-    ruleExecutions
+    caseId: suiteCase.id,
+    runId: runKey,
+    missing: true,
+    reason: `no trace found for run id "${runKey}" under ${options.tracesDir}`
   };
 }
 
@@ -3236,16 +3238,20 @@ function normalizeTokenUsage(value) {
   const output = nonNegativeFinite(value.output);
   const suppliedTotal = nonNegativeFinite(value.total);
   const cached = nonNegativeFinite(value.cached);
+  const cacheWrite = nonNegativeFinite(value.cacheWrite);
+  const reasoning = nonNegativeFinite(value.reasoning);
   const derivedTotal = input !== void 0 && output !== void 0 && Number.isFinite(input + output) ? input + output : void 0;
   const total = suppliedTotal ?? derivedTotal;
-  if (input === void 0 && output === void 0 && total === void 0 && cached === void 0) {
+  if (input === void 0 && output === void 0 && total === void 0 && cached === void 0 && cacheWrite === void 0 && reasoning === void 0) {
     return void 0;
   }
   return {
     ...input !== void 0 ? { input } : {},
     ...output !== void 0 ? { output } : {},
     ...total !== void 0 ? { total } : {},
-    ...cached !== void 0 ? { cached } : {}
+    ...cached !== void 0 ? { cached } : {},
+    ...cacheWrite !== void 0 ? { cacheWrite } : {},
+    ...reasoning !== void 0 ? { reasoning } : {}
   };
 }
 
@@ -4404,6 +4410,8 @@ function readOpenInferenceTokenUsage(attributes) {
   const completion = attributes["llm.token_count.completion"];
   const total = attributes["llm.token_count.total"];
   const cached = attributes["llm.token_count.prompt_details.cache_read"];
+  const cacheWrite = attributes["llm.token_count.prompt_details.cache_write"] ?? attributes["llm.token_count.prompt_details.cache_creation"];
+  const reasoning = attributes["llm.token_count.completion_details.reasoning"] ?? attributes["llm.token_count.completion_details.reasoning_tokens"];
   const usage = {};
   if (typeof prompt === "number" && Number.isFinite(prompt) && prompt >= 0) {
     usage.input = prompt;
@@ -4417,6 +4425,12 @@ function readOpenInferenceTokenUsage(attributes) {
   if (typeof cached === "number" && Number.isFinite(cached) && cached >= 0) {
     usage.cached = cached;
   }
+  if (typeof cacheWrite === "number" && Number.isFinite(cacheWrite) && cacheWrite >= 0) {
+    usage.cacheWrite = cacheWrite;
+  }
+  if (typeof reasoning === "number" && Number.isFinite(reasoning) && reasoning >= 0) {
+    usage.reasoning = reasoning;
+  }
   if (usage.total === void 0 && usage.input !== void 0 && usage.output !== void 0) {
     usage.total = usage.input + usage.output;
   }