agent-inspect 6.31.9 → 6.31.11

package/packages/core/dist/advanced.cjs

@@ -4306,7 +4306,7 @@ function stepMixLine(summary) {
   if (summary.logicSteps > 0) parts.push(`${summary.logicSteps} logic`);
   return parts.length > 0 ? parts.join(", ") : "none";
 }
-function outcomeLine(summary) {
+function executionLine(summary) {
   if (summary.status === "success") {
     return summary.errorSteps > 0 ? "Completed with step errors recorded." : "Completed successfully.";
   }
@@ -4324,7 +4324,7 @@ function outcomeLine(summary) {
   if (summary.status === "running") {
     return "Run is still in progress (no run_completed).";
   }
-  return "Outcome unknown \u2014 inspect events may be incomplete.";
+  return "Execution status unknown \u2014 inspect events may be incomplete.";
 }
 function buildRunWhatSummary(events) {
   const base = buildRunSummary(events);
@@ -4415,7 +4415,7 @@ function renderRunWhat(summary, options = {}) {
       lines.push(`Correlation: ${parts.join(", ")}`);
     }
   }
-  lines.push(`Outcome: ${outcomeLine(summary)}`);
+  lines.push(`Execution: ${executionLine(summary)}`);
   if (summary.longestStep && summary.totalSteps > 0) {
     lines.push(
       `Slowest: ${summary.longestStep.name} (${formatDuration2(summary.longestStep.durationMs)}, ${summary.longestStep.type})`
@@ -4569,2061 +4569,2120 @@ function findFirstCausalFailure(events, options = {}) {
   );
 }
 
-// packages/core/src/explain.ts
-function toDisplayStatus(status) {
-  if (status === "ok") return "success";
-  if (status === "error") return "error";
-  if (status === "running") return "running";
-  return "unknown";
-}
-function flatten(nodes, out = []) {
-  for (const node of nodes) {
-    out.push({ node, index: out.length + 1 });
-    flatten(node.children, out);
+// 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"]
+  },
+  AI_TRACE_CONTRACT_INPUT_INVALID: {
+    code: "AI_TRACE_CONTRACT_INPUT_INVALID",
+    summary: "evaluateTraceContract expects ({ read }, contract) or use evaluateTraceContractRead(read, contract).",
+    remediation: "Pass TraceCheckInput as the first argument: evaluateTraceContract({ read }, contract).",
+    relatedCodes: ["AI_CHECK_INVALID_ARGUMENTS"]
+  },
+  AI_INSPECT_RUN_UNSUPPORTED_OPTION: {
+    code: "AI_INSPECT_RUN_UNSUPPORTED_OPTION",
+    summary: 'inspectRun does not accept a "writer" option.',
+    remediation: "Use createInspector({ writer }) then inspector.run(...). inspectRun persists via the global JSONL path (schema 0.1)."
   }
-  return out;
-}
-function redactValue(redactor, key, value) {
-  return redactor.redactValue(key, value);
-}
-function fact(id, label, value, redactor) {
-  return {
-    id,
-    label,
-    value: redactValue(redactor, id.split(".").at(-1) ?? id, value),
-    source: "trace",
-    confidence: "observed"
-  };
+});
+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 topKinds(run) {
-  return Object.entries(run.metadata.kinds).filter(([, count]) => count > 0).sort((a, b) => {
-    if (b[1] !== a[1]) return b[1] - a[1];
-    return a[0].localeCompare(b[0]);
-  }).slice(0, 5).map(([kind, count]) => `${kind}:${count}`);
+
+// packages/core/src/checks/logical-events.ts
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function countErrorNodes(nodes) {
-  return nodes.filter((entry) => entry.node.event.status === "error").length;
+function legacyEvent(event) {
+  const value = event.attributes?.legacyEvent;
+  return typeof value === "string" ? value : void 0;
 }
-function slowestNode(nodes) {
-  return nodes.filter(
-    (entry) => entry.node.event.durationMs !== void 0 && // The RUN boundary spans the whole run, so its duration always dominates
-    // and shadows every real step. Rank actual work nodes only, matching the
-    // stats slowest-step ranking, which never counts the run envelope.
-    entry.node.event.kind !== "RUN"
-  ).sort((a, b) => {
-    const delta = (b.node.event.durationMs ?? 0) - (a.node.event.durationMs ?? 0);
-    return delta !== 0 ? delta : a.index - b.index;
-  })[0];
+function stepIdOf(event) {
+  const value = event.attributes?.stepId;
+  if (typeof value === "string" && value.trim() !== "") return value;
+  return void 0;
 }
-function attributeFacts(nodes, redactor) {
-  const facts = [];
-  for (const entry of nodes) {
-    const attrs = entry.node.event.attributes;
-    if (attrs === void 0) continue;
-    for (const key of Object.keys(attrs).sort()) {
-      facts.push({
-        id: `node.${entry.index}.attributes.${key}`,
-        label: `${entry.node.event.name} attribute ${key}`,
-        value: redactValue(redactor, key, attrs[key]),
-        source: "trace",
-        confidence: "observed"
-      });
-      if (facts.length >= 8) return facts;
-    }
-  }
-  return facts;
+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 buildFacts(run, redactor) {
-  const nodes = flatten(run.children);
-  const facts = [
-    fact("run.id", "Run id", run.runId, redactor),
-    fact("run.name", "Run name", run.name ?? run.runId, redactor),
-    fact("run.status", "Run status", toDisplayStatus(run.status), redactor),
-    fact("run.totalEvents", "Total events", run.metadata.totalEvents, redactor),
-    fact("run.stepCount", "Top-level step count", run.children.length, redactor),
-    fact("run.nodeCount", "Total node count", nodes.length, redactor),
-    fact("run.errorNodeCount", "Error node count", countErrorNodes(nodes), redactor),
-    fact("run.kinds", "Observed kind mix", topKinds(run), redactor)
-  ];
-  if (run.durationMs !== void 0) {
-    facts.push(fact("run.durationMs", "Run duration milliseconds", run.durationMs, redactor));
-  }
-  const slowest = slowestNode(nodes);
-  if (slowest !== void 0) {
-    facts.push(
-      fact("run.slowestNode", "Slowest observed node", {
-        name: slowest.node.event.name,
-        kind: slowest.node.event.kind,
-        durationMs: slowest.node.event.durationMs
-      }, redactor)
-    );
+function mergeAttributes(start, complete) {
+  const merged = {
+    ...isRecord7(complete.attributes) ? complete.attributes : {},
+    ...isRecord7(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;
   }
-  facts.push(...attributeFacts(nodes, redactor));
-  return facts;
+  return Object.keys(merged).length > 0 ? merged : void 0;
 }
-function buildInferences(run, facts) {
-  const inferences = [];
-  const errorFact = facts.find((item) => item.id === "run.errorNodeCount");
-  const kindFact = facts.find((item) => item.id === "run.kinds");
-  const durationFact = facts.find((item) => item.id === "run.durationMs");
-  const errorNodeCount = typeof errorFact?.value === "number" ? errorFact.value : 0;
-  if (run.status === "error" || errorNodeCount > 0) {
-    inferences.push({
-      id: "outcome.error",
-      label: "Outcome",
-      text: "The run recorded an error status or at least one error node.",
-      evidence: ["run.status", "run.errorNodeCount"],
-      confidence: "deterministic"
-    });
-  } else if (run.status === "ok") {
-    inferences.push({
-      id: "outcome.success",
-      label: "Outcome",
-      text: "The run completed without observed error nodes.",
-      evidence: ["run.status", "run.errorNodeCount"],
-      confidence: "deterministic"
-    });
-  }
-  if (kindFact !== void 0) {
-    inferences.push({
-      id: "shape.kind-mix",
-      label: "Trace shape",
-      text: "The explanation is based on the observed event kind mix, not generated content.",
-      evidence: [kindFact.id],
-      confidence: "deterministic"
-    });
-  }
-  if (durationFact !== void 0) {
-    inferences.push({
-      id: "timing.duration",
-      label: "Timing",
-      text: "Timing claims are limited to persisted duration fields in the trace.",
-      evidence: [durationFact.id],
-      confidence: "deterministic"
-    });
-  }
-  return inferences;
+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 {
+    ...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 } : {}
+    }
+  };
 }
-function buildLocalExplanation(run, options = {}) {
-  const redactionProfile = options.redactionProfile ?? "local";
-  const resolved = resolveRedactionProfile(redactionProfile);
-  const redactor = new Redactor({ extraKeys: resolved.extraKeys });
-  const mode = options.mode ?? "local";
-  const facts = buildFacts(run, redactor);
+function asLogical(event, extras) {
   return {
-    mode,
-    runId: String(redactValue(redactor, "runId", run.runId)),
-    ...run.name !== void 0 ? { name: String(redactValue(redactor, "name", run.name)) } : {},
-    ...run.status !== void 0 ? { status: toDisplayStatus(run.status) } : {},
-    redactionProfile,
-    facts,
-    inferences: mode === "dry-run" ? [] : buildInferences(run, facts),
-    notes: [
-      "Generated locally without provider or network calls.",
-      "Facts are observed from normalized trace data; inferences are deterministic labels."
-    ]
+    ...cloneEvent(event),
+    sourceEventIds: Object.freeze([event.eventId]),
+    projection: {
+      paired: false,
+      absorbedEventIds: Object.freeze([]),
+      parentNormalized: extras?.parentNormalized === true,
+      ...{}
+    }
   };
 }
-
-// packages/core/src/search.ts
-function parseDurationFilter(expr) {
-  const raw = expr.trim();
-  const m = raw.match(/^(>=|<=|>|<)\s*(.+)$/);
-  if (!m) {
-    throw new Error(
-      `Invalid --duration "${expr}". Use forms like >5s, >=500ms, <2m.`
-    );
-  }
-  const op = m[1];
-  const ms = parseDuration(m[2].trim());
-  return { op, ms };
-}
-function durationMatches(valueMs, filter) {
-  if (valueMs === void 0 || !Number.isFinite(valueMs)) return false;
-  switch (filter.op) {
-    case ">":
-      return valueMs > filter.ms;
-    case ">=":
-      return valueMs >= filter.ms;
-    case "<":
-      return valueMs < filter.ms;
-    case "<=":
-      return valueMs <= filter.ms;
-    default:
-      return false;
-  }
-}
-function normalizeStepTypeFilter(kind, type) {
-  const v = (kind ?? type)?.trim().toLowerCase();
-  return v && v !== "" ? v : void 0;
-}
-function nameMatches(hay, needle) {
-  return hay.toLowerCase().includes(needle.toLowerCase());
-}
-async function searchTraces(metas, options) {
-  let filtered = filterTraces(metas, { since: options.since });
-  const stepTypeFilter = normalizeStepTypeFilter(options.kind, options.type);
-  const nameQuery = options.name?.trim();
-  const toolQuery = options.tool?.trim();
-  let durationFilter;
-  if (options.duration) {
-    durationFilter = parseDurationFilter(options.duration);
+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 limit = options.limit ?? 50;
-  const sessionId = options.session?.trim();
-  const observationStatus2 = parseObservationFilter(options.observation);
-  const hasContentFilter = Boolean(
-    options.status || stepTypeFilter || nameQuery || toolQuery || durationFilter || observationStatus2
-  );
-  const results = [];
-  const sessionLabel = sessionId && sessionId !== "" ? sessionId : void 0;
-  if (!hasContentFilter) {
-    for (const m of filtered) {
-      results.push({
-        runId: m.runId,
-        runName: m.name,
-        runStatus: m.status,
-        timestamp: m.startedAt,
-        durationMs: m.durationMs,
-        matchReason: sessionLabel ? `trace in session ${sessionLabel}` : "trace in directory",
-        matchedFields: sessionLabel ? ["run", "session"] : ["run"],
-        filePath: m.filePath,
-        ...sessionLabel ? { sessionId: sessionLabel } : {}
+  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);
+      }
+    }
+    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 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);
+      }
     }
-    results.sort((a, b) => {
-      const ta = a.timestamp ?? 0;
-      const tb = b.timestamp ?? 0;
-      if (ta !== tb) return tb - ta;
-      return a.runId.localeCompare(b.runId);
-    });
-    return results.slice(0, limit);
   }
-  for (const m of filtered) {
-    if (options.status && m.status !== options.status) continue;
-    let events = [];
-    try {
-      events = await readTraceEventsFromFile(m.filePath);
-    } catch {
+  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;
     }
-    if (events.length === 0) continue;
-    const runMatches = matchRunLevel(m, {
-      stepTypeFilter,
-      nameQuery,
-      toolQuery,
-      durationFilter,
-      statusFilter: options.status
-    });
-    results.push(...runMatches);
-    const stepMatches = matchStepLevel(m, events, {
-      stepTypeFilter,
-      nameQuery,
-      toolQuery,
-      durationFilter,
-      statusFilter: options.status
-    });
-    results.push(...stepMatches);
-    if (observationStatus2) {
-      const outcomes = extractOutcomesFromTraceEvents(events);
-      const matched = outcomes.filter((outcome) => outcome.status === observationStatus2);
-      for (const outcome of matched) {
-        results.push({
-          runId: m.runId,
-          runName: m.name,
-          runStatus: m.status,
-          stepName: outcome.name,
-          timestamp: outcome.observedAt,
-          matchReason: `observation status=${outcome.status}`,
-          matchedFields: ["outcome.status", "outcome.name"],
-          filePath: m.filePath
+    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;
     }
-  }
-  results.sort((a, b) => {
-    const ta = a.timestamp ?? 0;
-    const tb = b.timestamp ?? 0;
-    if (ta !== tb) return tb - ta;
-    const runCmp = a.runId.localeCompare(b.runId);
-    if (runCmp !== 0) return runCmp;
-    return (a.stepName ?? "").localeCompare(b.stepName ?? "");
-  });
-  return results.slice(0, limit);
-}
-function matchRunLevel(m, opts) {
-  if (opts.stepTypeFilter || opts.toolQuery) return [];
-  if (opts.statusFilter && m.status !== opts.statusFilter) return [];
-  if (opts.nameQuery && !nameMatches(m.name ?? m.runId, opts.nameQuery)) {
-    return [];
-  }
-  if (opts.durationFilter && !durationMatches(m.durationMs, opts.durationFilter)) {
-    return [];
-  }
-  const fields = [];
-  if (opts.statusFilter) fields.push("run.status");
-  if (opts.nameQuery) fields.push("run.name");
-  if (opts.durationFilter) fields.push("run.durationMs");
-  if (fields.length === 0) return [];
-  return [
-    {
-      runId: m.runId,
-      runName: m.name,
-      runStatus: m.status,
-      timestamp: m.startedAt,
-      durationMs: m.durationMs,
-      matchReason: `run match: ${fields.join(", ")}`,
-      matchedFields: fields,
-      filePath: m.filePath
-    }
-  ];
-}
-function matchStepLevel(m, events, opts) {
-  const out = [];
-  const started = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    if (e.event === "step_started") {
-      started.set(e.stepId, e);
-    }
-  }
-  for (const e of events) {
-    if (e.event !== "step_completed") continue;
-    const c = e;
-    const s = started.get(c.stepId);
-    if (!s) continue;
-    const fields = [];
-    const stepType = s.type;
-    if (opts.stepTypeFilter && stepType !== opts.stepTypeFilter) {
-      continue;
-    }
-    const hasStepFilters = opts.stepTypeFilter || opts.nameQuery || opts.toolQuery || opts.durationFilter || opts.statusFilter === "error" || opts.statusFilter === "success";
-    if (!hasStepFilters) continue;
-    if (opts.statusFilter === "error" && c.status === "error") {
-      fields.push("step.status");
-    } else if (opts.statusFilter === "success" && c.status === "success") {
-      fields.push("step.status");
-    } else if (opts.statusFilter === "error" || opts.statusFilter === "success") {
+    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;
     }
-    if (opts.nameQuery) {
-      if (!nameMatches(s.name, opts.nameQuery)) continue;
-      fields.push("step.name");
-    }
-    if (opts.toolQuery) {
-      const toolName2 = typeof s.metadata?.toolName === "string" ? s.metadata.toolName : s.name;
-      if (!nameMatches(toolName2, opts.toolQuery)) continue;
-      fields.push("step.tool");
-    }
-    if (opts.durationFilter) {
-      if (!durationMatches(c.durationMs, opts.durationFilter)) continue;
-      fields.push("step.durationMs");
-    }
-    if (opts.stepTypeFilter) {
-      fields.push("step.type");
-    }
-    if (fields.length === 0) continue;
-    out.push({
-      runId: m.runId,
-      runName: m.name,
-      runStatus: m.status,
-      stepId: c.stepId,
-      stepName: s.name,
-      stepType,
-      timestamp: s.startTime ?? s.timestamp,
-      durationMs: c.durationMs,
-      matchReason: `step match: ${fields.join(", ")}`,
-      matchedFields: fields,
-      filePath: m.filePath
+    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
+      }
     });
   }
-  return out;
+  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)
+  };
 }
-async function loadTraceMetadataList(_traceDir, fileNames, getPath) {
-  const metas = [];
-  for (const fileName of fileNames) {
-    try {
-      const filePath = getPath(fileName);
-      const meta = await extractMetadata(filePath);
-      metas.push(meta);
-    } catch {
-    }
+function resolveCanonicalToolName(event) {
+  const attrs = event.attributes;
+  const direct = pickString(attrs, ["toolName", "tool"]);
+  if (direct) return direct;
+  const metadata = attrs?.metadata;
+  if (isRecord7(metadata)) {
+    const nested = pickString(metadata, ["toolName", "tool"]);
+    if (nested) return nested;
   }
-  return metas;
-}
-
-// packages/core/src/sessions/metadata.ts
-function isNonEmptyString3(value) {
-  return typeof value === "string" && value.trim() !== "";
-}
-function finitePositiveInt(value) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
-    return void 0;
+  for (const prefix of ["tool:", "function:", "mcp-tools:"]) {
+    if (event.name.startsWith(prefix)) return event.name.slice(prefix.length);
   }
-  return Math.trunc(value);
+  return event.name;
 }
-function extractSessionWorkflowMetadata(record) {
+function pickString(record, keys) {
   if (!record) return void 0;
-  const out = {};
-  let found = false;
-  const assignString = (key, value) => {
-    if (isNonEmptyString3(value)) {
-      out[key] = value.trim();
-      found = true;
-    }
-  };
-  assignString("sessionId", record.sessionId);
-  assignString("conversationId", record.conversationId);
-  assignString("groupId", record.groupId);
-  assignString("parentGroupId", record.parentGroupId);
-  assignString("retryOf", record.retryOf);
-  assignString("retryReason", record.retryReason);
-  assignString("handoffFrom", record.handoffFrom);
-  assignString("handoffTo", record.handoffTo);
-  assignString("subAgentId", record.subAgentId);
-  assignString("subAgentName", record.subAgentName);
-  assignString("jobId", record.jobId);
-  assignString("queueName", record.queueName);
-  assignString("workflowName", record.workflowName);
-  assignString("workflowStep", record.workflowStep);
-  assignString("toolCallId", record.toolCallId);
-  assignString("mcpToolCallId", record.mcpToolCallId);
-  assignString("linkedStepId", record.linkedStepId);
-  assignString("operationId", record.operationId);
-  assignString("attemptId", record.attemptId);
-  assignString("fallbackOf", record.fallbackOf);
-  assignString("idempotencyKey", record.idempotencyKey);
-  assignString("correlationId", record.correlationId);
-  assignString("requestId", record.requestId);
-  assignString("decisionId", record.decisionId);
-  const attempt = finitePositiveInt(record.attempt);
-  if (attempt !== void 0) {
-    out.attempt = attempt;
-    found = true;
-  }
-  const attemptNumber = finitePositiveInt(record.attemptNumber);
-  if (attemptNumber !== void 0) {
-    out.attemptNumber = attemptNumber;
-    found = true;
-  }
-  return found ? out : void 0;
-}
-function sessionKeyForRun(meta, options) {
-  if (meta?.sessionId) return meta.sessionId;
-  if (options?.correlateByGroupId && meta?.groupId) {
-    return `group:${meta.groupId}`;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
   }
   return void 0;
 }
 
-// packages/core/src/sessions/status.ts
-var DEFAULT_STALE_THRESHOLD_MS = 864e5;
-var EXPLICIT_STATUS_PRIORITY = {
-  error: 5,
-  waiting_input: 4,
-  idle: 3,
-  stale: 2,
-  completed: 1
-};
-var EXPLICIT_SESSION_STATUSES = /* @__PURE__ */ new Set([
-  "running",
-  "waiting_input",
-  "idle",
-  "completed",
-  "error",
-  "stale",
-  "unknown"
-]);
-function isExplicitSessionStatus(value) {
-  return typeof value === "string" && EXPLICIT_SESSION_STATUSES.has(value);
-}
-function activityMs(run) {
-  return run.endedAt ?? run.startedAt ?? 0;
+// packages/core/src/explain.ts
+function toDisplayStatus(status) {
+  if (status === "ok") return "success";
+  if (status === "error") return "error";
+  if (status === "running") return "running";
+  return "unknown";
 }
-function latestActivityMs(runs) {
-  let latest = 0;
-  for (const run of runs) {
-    const ms = activityMs(run);
-    if (ms > latest) latest = ms;
+function flatten(nodes, out = []) {
+  for (const node of nodes) {
+    out.push({ node, index: out.length + 1 });
+    flatten(node.children, out);
   }
-  return latest;
+  return out;
 }
-function earliestStart(runs) {
-  let earliest;
-  for (const run of runs) {
-    if (run.startedAt === void 0) continue;
-    if (earliest === void 0 || run.startedAt < earliest) {
-      earliest = run.startedAt;
-    }
-  }
-  return earliest;
+function redactValue(redactor, key, value) {
+  return redactor.redactValue(key, value);
 }
-function latestEndWhenAllEnded(runs) {
-  if (runs.length === 0) return void 0;
-  let latest;
-  for (const run of runs) {
-    if (run.endedAt === void 0) return void 0;
-    if (latest === void 0 || run.endedAt > latest) latest = run.endedAt;
-  }
-  return latest;
+function fact(id, label, value, redactor) {
+  return {
+    id,
+    label,
+    value: redactValue(redactor, id.split(".").at(-1) ?? id, value),
+    source: "trace",
+    confidence: "observed"
+  };
 }
-function pickExplicitStatus(runs) {
-  let best;
-  let bestPriority = 0;
-  for (const run of runs) {
-    const raw = run.metadata?.sessionStatus;
-    if (!isExplicitSessionStatus(raw)) continue;
-    const priority = EXPLICIT_STATUS_PRIORITY[raw] ?? 0;
-    if (priority > bestPriority) {
-      bestPriority = priority;
-      best = raw;
-    }
-  }
-  return best;
+function topKinds(run) {
+  return Object.entries(run.metadata.kinds).filter(([, count]) => count > 0).sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    return a[0].localeCompare(b[0]);
+  }).slice(0, 5).map(([kind, count]) => `${kind}:${count}`);
 }
-function deriveLastError(runs) {
-  const errorRuns = runs.filter((run) => run.status === "error").sort((a, b) => activityMs(b) - activityMs(a));
-  const latest = errorRuns[0];
-  if (!latest) return void 0;
-  const meta = latest.metadata ?? {};
-  const message = typeof meta.errorMessage === "string" && meta.errorMessage.trim() !== "" ? meta.errorMessage.trim() : latest.name ?? latest.runId;
-  const code = typeof meta.errorCode === "string" && meta.errorCode.trim() !== "" ? meta.errorCode.trim() : void 0;
-  return { runId: latest.runId, message, code };
+function countErrorNodes(nodes) {
+  return nodes.filter((entry) => entry.node.event.status === "error").length;
 }
-function deriveCheckSummary(runs) {
-  let pass = 0;
-  let fail = 0;
-  let warn2 = 0;
-  let found = false;
-  for (const run of runs) {
-    const summary = run.metadata?.checkSummary;
-    if (!summary || typeof summary !== "object") continue;
-    const record = summary;
-    if (typeof record.pass === "number") {
-      pass += record.pass;
-      found = true;
-    }
-    if (typeof record.fail === "number") {
-      fail += record.fail;
-      found = true;
-    }
-    if (typeof record.warn === "number") {
-      warn2 += record.warn;
-      found = true;
+function slowestNode(nodes) {
+  return nodes.filter(
+    (entry) => entry.node.event.durationMs !== void 0 && // The RUN boundary spans the whole run, so its duration always dominates
+    // and shadows every real step. Rank actual work nodes only, matching the
+    // stats slowest-step ranking, which never counts the run envelope.
+    entry.node.event.kind !== "RUN"
+  ).sort((a, b) => {
+    const delta = (b.node.event.durationMs ?? 0) - (a.node.event.durationMs ?? 0);
+    return delta !== 0 ? delta : a.index - b.index;
+  })[0];
+}
+function attributeFacts(nodes, redactor) {
+  const facts = [];
+  for (const entry of nodes) {
+    const attrs = entry.node.event.attributes;
+    if (attrs === void 0) continue;
+    for (const key of Object.keys(attrs).sort()) {
+      facts.push({
+        id: `node.${entry.index}.attributes.${key}`,
+        label: `${entry.node.event.name} attribute ${key}`,
+        value: redactValue(redactor, key, attrs[key]),
+        source: "trace",
+        confidence: "observed"
+      });
+      if (facts.length >= 8) return facts;
     }
   }
-  return found ? { pass, fail, warn: warn2 } : void 0;
+  return facts;
 }
-function deriveObservationSummary(runs) {
-  for (const run of [...runs].sort((a, b) => activityMs(b) - activityMs(a))) {
-    const value = run.metadata?.observationSummary;
-    if (typeof value === "string" && value.trim() !== "") {
-      return value.trim();
+function buildFacts(run, redactor, events) {
+  const nodes = flatten(run.children);
+  const facts = [
+    fact("run.id", "Run id", run.runId, redactor),
+    fact("run.name", "Run name", run.name ?? run.runId, redactor),
+    fact("run.status", "Run status", toDisplayStatus(run.status), redactor),
+    fact("run.totalEvents", "Total events", run.metadata.totalEvents, redactor),
+    fact("run.stepCount", "Top-level step count", run.children.length, redactor),
+    fact("run.nodeCount", "Total node count", nodes.length, redactor),
+    fact("run.errorNodeCount", "Error node count", countErrorNodes(nodes), redactor),
+    fact("run.kinds", "Observed kind mix", topKinds(run), redactor)
+  ];
+  if (run.durationMs !== void 0) {
+    facts.push(fact("run.durationMs", "Run duration milliseconds", run.durationMs, redactor));
+  }
+  const slowest = slowestNode(nodes);
+  if (slowest !== void 0) {
+    facts.push(
+      fact("run.slowestNode", "Slowest observed node", {
+        name: slowest.node.event.name,
+        kind: slowest.node.event.kind,
+        durationMs: slowest.node.event.durationMs
+      }, redactor)
+    );
+  }
+  if (events !== void 0) {
+    const scoped = events.filter((event) => event.runId === run.runId);
+    const { logicalEvents: logical } = projectLogicalEvents(scoped);
+    const logicalSteps = logical.filter((event) => event.kind !== "RUN");
+    facts.push(
+      fact("run.rawEventCount", "Raw persisted event count", scoped.length, redactor),
+      fact(
+        "run.logicalStepCount",
+        "Logical lifecycle step count",
+        logicalSteps.length,
+        redactor
+      ),
+      fact(
+        "run.logicalEventCount",
+        "Logical lifecycle event count (including RUN)",
+        logical.length,
+        redactor
+      )
+    );
+    const slowestLogical = [...logicalSteps].filter((event) => typeof event.durationMs === "number").sort((a, b) => {
+      const delta = (b.durationMs ?? 0) - (a.durationMs ?? 0);
+      return delta !== 0 ? delta : a.eventId.localeCompare(b.eventId);
+    })[0];
+    if (slowestLogical !== void 0) {
+      facts.push(
+        fact("run.slowestLogicalStep", "Slowest logical lifecycle step", {
+          name: slowestLogical.name,
+          kind: slowestLogical.kind,
+          durationMs: slowestLogical.durationMs
+        }, redactor)
+      );
     }
   }
-  return void 0;
-}
-function deriveSessionStatus(runs, options = {}) {
-  if (runs.length === 0) return "unknown";
-  if (runs.some((run) => run.status === "running")) return "running";
-  const explicit = pickExplicitStatus(runs);
-  if (explicit && explicit !== "running") return explicit;
-  if (runs.some((run) => run.status === "error")) return "error";
-  if (runs.every((run) => run.status === "success")) return "completed";
-  const nowMs = options.nowMs ?? Date.now();
-  const staleThresholdMs = options.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
-  const lastMs = latestActivityMs(runs);
-  if (lastMs > 0 && nowMs - lastMs > staleThresholdMs) return "stale";
-  return "unknown";
+  facts.push(...attributeFacts(nodes, redactor));
+  return facts;
 }
-function enrichSessionSummary(summary, runs, options = {}) {
-  const sessionRuns = runs.filter((run) => summary.runIds.includes(run.runId)).sort((a, b) => a.runId.localeCompare(b.runId));
-  const startedAt = earliestStart(sessionRuns);
-  const endedAt = latestEndWhenAllEnded(sessionRuns);
-  const durationMs2 = startedAt !== void 0 && endedAt !== void 0 ? endedAt - startedAt : void 0;
-  let correlationId;
-  let jobId;
-  let workflowId;
-  for (const run of sessionRuns) {
-    const meta = extractSessionWorkflowMetadata(run.metadata);
-    if (!correlationId && meta?.correlationId) correlationId = meta.correlationId;
-    if (!jobId && meta?.jobId) jobId = meta.jobId;
-    if (!workflowId && meta?.workflowName) workflowId = meta.workflowName;
-    else if (!workflowId && meta?.workflowStep) workflowId = meta.workflowStep;
+function buildInferences(run, facts) {
+  const inferences = [];
+  const errorFact = facts.find((item) => item.id === "run.errorNodeCount");
+  const kindFact = facts.find((item) => item.id === "run.kinds");
+  const durationFact = facts.find((item) => item.id === "run.durationMs");
+  const errorNodeCount = typeof errorFact?.value === "number" ? errorFact.value : 0;
+  if (run.status === "error" || errorNodeCount > 0) {
+    inferences.push({
+      id: "outcome.error",
+      label: "Outcome",
+      text: "The run recorded an error status or at least one error node.",
+      evidence: ["run.status", "run.errorNodeCount"],
+      confidence: "deterministic"
+    });
+  } else if (run.status === "ok") {
+    inferences.push({
+      id: "outcome.success",
+      label: "Outcome",
+      text: "The run completed without observed error nodes.",
+      evidence: ["run.status", "run.errorNodeCount"],
+      confidence: "deterministic"
+    });
   }
-  const lastMs = latestActivityMs(sessionRuns);
-  const lastActivity = lastMs > 0 ? new Date(lastMs).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
-  const retryCount2 = summary.retries.filter(
-    (retry) => retry.retryOf !== void 0 || (retry.attempt ?? 0) > 1
-  ).length;
+  if (kindFact !== void 0) {
+    inferences.push({
+      id: "shape.kind-mix",
+      label: "Trace shape",
+      text: "The explanation is based on the observed event kind mix, not generated content.",
+      evidence: [kindFact.id],
+      confidence: "deterministic"
+    });
+  }
+  if (durationFact !== void 0) {
+    inferences.push({
+      id: "timing.duration",
+      label: "Timing",
+      text: "Timing claims are limited to persisted duration fields in the trace.",
+      evidence: [durationFact.id],
+      confidence: "deterministic"
+    });
+  }
+  return inferences;
+}
+function buildLocalExplanation(run, options = {}) {
+  const redactionProfile = options.redactionProfile ?? "local";
+  const resolved = resolveRedactionProfile(redactionProfile);
+  const redactor = new Redactor({ extraKeys: resolved.extraKeys });
+  const mode = options.mode ?? "local";
+  const facts = buildFacts(run, redactor, options.events);
   return {
-    ...summary,
-    status: deriveSessionStatus(sessionRuns, options),
-    startedAt,
-    endedAt,
-    durationMs: durationMs2,
-    correlationId,
-    jobId,
-    workflowId,
-    lastError: deriveLastError(sessionRuns),
-    lastActivity,
-    retryCount: retryCount2,
-    observationSummary: deriveObservationSummary(sessionRuns),
-    checkSummary: deriveCheckSummary(sessionRuns)
+    mode,
+    runId: String(redactValue(redactor, "runId", run.runId)),
+    ...run.name !== void 0 ? { name: String(redactValue(redactor, "name", run.name)) } : {},
+    ...run.status !== void 0 ? { status: toDisplayStatus(run.status) } : {},
+    redactionProfile,
+    facts,
+    inferences: mode === "dry-run" ? [] : buildInferences(run, facts),
+    notes: [
+      "Generated locally without provider or network calls.",
+      "Facts are observed from normalized trace data; inferences are deterministic labels."
+    ]
   };
 }
 
-// packages/core/src/sessions/activity.ts
-function statusLine(session) {
-  const name = session.workflowId ?? session.correlationId ?? session.sessionId;
-  const status = session.status;
-  if (session.lastError) {
-    return `${name} session ${session.sessionId} failed at ${session.lastError.message}`;
+// packages/core/src/search.ts
+function parseDurationFilter(expr) {
+  const raw = expr.trim();
+  const m = raw.match(/^(>=|<=|>|<)\s*(.+)$/);
+  if (!m) {
+    throw new Error(
+      `Invalid --duration "${expr}". Use forms like >5s, >=500ms, <2m.`
+    );
   }
-  if (session.observationSummary) {
-    return `${name} session ${session.sessionId} ${status} with observation warning`;
-  }
-  return `${name} session ${session.sessionId} ${status}`;
-}
-function parseSinceMs(since, nowMs) {
-  if (!since || since.trim() === "") return nowMs - 7 * 864e5;
-  const trimmed = since.trim().toLowerCase();
-  const match = /^(\d+)([smhd])$/.exec(trimmed);
-  if (!match) return nowMs - 7 * 864e5;
-  const amount = Number.parseInt(match[1], 10);
-  const unit = match[2];
-  const mult = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
-  return nowMs - amount * mult;
+  const op = m[1];
+  const ms = parseDuration(m[2].trim());
+  return { op, ms };
 }
-function isFailed(status) {
-  return status === "error";
+function durationMatches(valueMs, filter) {
+  if (valueMs === void 0 || !Number.isFinite(valueMs)) return false;
+  switch (filter.op) {
+    case ">":
+      return valueMs > filter.ms;
+    case ">=":
+      return valueMs >= filter.ms;
+    case "<":
+      return valueMs < filter.ms;
+    case "<=":
+      return valueMs <= filter.ms;
+    default:
+      return false;
+  }
 }
-function isStale(status) {
-  return status === "stale";
+function normalizeStepTypeFilter(kind, type) {
+  const v = (kind ?? type)?.trim().toLowerCase();
+  return v && v !== "" ? v : void 0;
 }
-function guardrailWarnings(session) {
-  const summary = session.checkSummary;
-  if (!summary) return 0;
-  return summary.warn;
+function nameMatches(hay, needle) {
+  return hay.toLowerCase().includes(needle.toLowerCase());
 }
-function buildActivitySummary(index, options = {}) {
-  const nowMs = options.nowMs ?? Date.now();
-  const sinceMs = parseSinceMs(options.since, nowMs);
-  const sinceIso = new Date(sinceMs).toISOString();
-  const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : 20;
-  const inWindow = index.sessions.filter((session) => {
-    const activityMs2 = Date.parse(session.lastActivity);
-    return Number.isFinite(activityMs2) && activityMs2 >= sinceMs;
-  });
-  const entries = [...inWindow].sort((a, b) => Date.parse(b.lastActivity) - Date.parse(a.lastActivity)).slice(0, limit).map((session) => ({
-    sessionId: session.sessionId,
-    status: session.status,
-    summary: statusLine(session),
-    lastActivity: session.lastActivity,
-    runCount: session.runIds.length
-  }));
-  let failed = 0;
-  let stale = 0;
-  let guardrailWarningTotal = 0;
-  for (const session of inWindow) {
-    if (isFailed(session.status)) failed += 1;
-    if (isStale(session.status)) stale += 1;
-    guardrailWarningTotal += guardrailWarnings(session);
+async function searchTraces(metas, options) {
+  let filtered = filterTraces(metas, { since: options.since });
+  const stepTypeFilter = normalizeStepTypeFilter(options.kind, options.type);
+  const nameQuery = options.name?.trim();
+  const toolQuery = options.tool?.trim();
+  let durationFilter;
+  if (options.duration) {
+    durationFilter = parseDurationFilter(options.duration);
   }
-  return {
-    since: sinceIso,
-    sessions: inWindow.length,
-    failed,
-    stale,
-    guardrailWarnings: guardrailWarningTotal,
-    entries
-  };
-}
-function renderActivitySummaryHuman(summary, options) {
-  const lines = [];
-  const nowMs = options?.nowMs ?? Date.now();
-  const todayStart = new Date(nowMs);
-  todayStart.setHours(0, 0, 0, 0);
-  const todayMs = todayStart.getTime();
-  const today = summary.entries.filter(
-    (entry) => Date.parse(entry.lastActivity) >= todayMs
+  const limit = options.limit ?? 50;
+  const sessionId = options.session?.trim();
+  const observationStatus2 = parseObservationFilter(options.observation);
+  const hasContentFilter = Boolean(
+    options.status || stepTypeFilter || nameQuery || toolQuery || durationFilter || observationStatus2
   );
-  if (today.length > 0) {
-    lines.push("Today");
-    for (const entry of today) {
-      lines.push(`  ${entry.summary}`);
+  const results = [];
+  const sessionLabel = sessionId && sessionId !== "" ? sessionId : void 0;
+  if (!hasContentFilter) {
+    for (const m of filtered) {
+      results.push({
+        runId: m.runId,
+        runName: m.name,
+        runStatus: m.status,
+        timestamp: m.startedAt,
+        durationMs: m.durationMs,
+        matchReason: sessionLabel ? `trace in session ${sessionLabel}` : "trace in directory",
+        matchedFields: sessionLabel ? ["run", "session"] : ["run"],
+        filePath: m.filePath,
+        ...sessionLabel ? { sessionId: sessionLabel } : {}
+      });
     }
-    lines.push("");
+    results.sort((a, b) => {
+      const ta = a.timestamp ?? 0;
+      const tb = b.timestamp ?? 0;
+      if (ta !== tb) return tb - ta;
+      return a.runId.localeCompare(b.runId);
+    });
+    return results.slice(0, limit);
   }
-  lines.push(`Since ${summary.since}`);
-  lines.push(`  ${summary.sessions} sessions`);
-  lines.push(`  ${summary.failed} failed`);
-  lines.push(`  ${summary.stale} stale`);
-  lines.push(`  ${summary.guardrailWarnings} guardrail warnings`);
-  return lines.join("\n");
-}
-
-// packages/core/src/sessions/types.ts
-var SESSION_WORKFLOW_KEYS = [
-  "sessionId",
-  "conversationId",
-  "groupId",
-  "parentGroupId",
-  "attempt",
-  "retryOf",
-  "retryReason",
-  "handoffFrom",
-  "handoffTo",
-  "subAgentId",
-  "subAgentName",
-  "jobId",
-  "queueName",
-  "workflowName",
-  "workflowStep",
-  "toolCallId",
-  "mcpToolCallId",
-  "linkedStepId",
-  "operationId",
-  "attemptId",
-  "attemptNumber",
-  "fallbackOf",
-  "idempotencyKey",
-  "correlationId",
-  "requestId",
-  "decisionId"
-];
-
-// packages/core/src/sessions/load.ts
-async function enrichSessionRunRecord(meta) {
-  let metadata;
-  try {
-    const events = await readTraceEventsFromFile(meta.filePath);
-    for (const event of events) {
-      if (event.event !== "run_started") continue;
-      if (event.metadata && typeof event.metadata === "object") {
-        metadata = event.metadata;
+  for (const m of filtered) {
+    if (options.status && m.status !== options.status) continue;
+    let events = [];
+    try {
+      events = await readTraceEventsFromFile(m.filePath);
+    } catch {
+      continue;
+    }
+    if (events.length === 0) continue;
+    const runMatches = matchRunLevel(m, {
+      stepTypeFilter,
+      nameQuery,
+      toolQuery,
+      durationFilter,
+      statusFilter: options.status
+    });
+    results.push(...runMatches);
+    const stepMatches = matchStepLevel(m, events, {
+      stepTypeFilter,
+      nameQuery,
+      toolQuery,
+      durationFilter,
+      statusFilter: options.status
+    });
+    results.push(...stepMatches);
+    if (observationStatus2) {
+      const outcomes = extractOutcomesFromTraceEvents(events);
+      const matched = outcomes.filter((outcome) => outcome.status === observationStatus2);
+      for (const outcome of matched) {
+        results.push({
+          runId: m.runId,
+          runName: m.name,
+          runStatus: m.status,
+          stepName: outcome.name,
+          timestamp: outcome.observedAt,
+          matchReason: `observation status=${outcome.status}`,
+          matchedFields: ["outcome.status", "outcome.name"],
+          filePath: m.filePath
+        });
       }
-      break;
     }
-  } catch {
   }
-  return {
-    runId: meta.runId,
-    name: meta.name,
-    status: meta.status,
-    startedAt: meta.startedAt,
-    endedAt: meta.endedAt,
-    durationMs: meta.durationMs,
-    filePath: meta.filePath,
-    metadata
-  };
+  results.sort((a, b) => {
+    const ta = a.timestamp ?? 0;
+    const tb = b.timestamp ?? 0;
+    if (ta !== tb) return tb - ta;
+    const runCmp = a.runId.localeCompare(b.runId);
+    if (runCmp !== 0) return runCmp;
+    return (a.stepName ?? "").localeCompare(b.stepName ?? "");
+  });
+  return results.slice(0, limit);
 }
-async function loadSessionRunRecords(metas) {
-  const out = [];
-  for (const meta of metas) {
-    out.push(await enrichSessionRunRecord(meta));
+function matchRunLevel(m, opts) {
+  if (opts.stepTypeFilter || opts.toolQuery) return [];
+  if (opts.statusFilter && m.status !== opts.statusFilter) return [];
+  if (opts.nameQuery && !nameMatches(m.name ?? m.runId, opts.nameQuery)) {
+    return [];
   }
-  return out;
-}
-
-// packages/core/src/sessions/scope.ts
-function metaToSessionRunRecord(meta) {
-  return {
-    runId: meta.runId,
-    name: meta.name,
-    status: meta.status,
-    startedAt: meta.startedAt,
-    endedAt: meta.endedAt,
-    durationMs: meta.durationMs,
-    filePath: meta.filePath,
-    metadata: void 0
-  };
-}
-function filterMetasBySessionScope(metas, records, options) {
-  const sessionId = options.sessionId?.trim();
-  const groupId = options.groupId?.trim();
-  const warnings = [];
-  if (sessionId) {
-    const index = buildSessionIndex(records, {
-      correlateByGroupId: options.correlateByGroupId === true
-    });
-    warnings.push(...index.warnings);
-    const session = index.sessions.find((item) => item.sessionId === sessionId);
-    if (!session) {
-      return {
-        metas: [],
-        scopeLabel: sessionId,
-        scopeKind: "session",
-        runIds: [],
-        warnings,
-        notFound: true
-      };
-    }
-    const runIdSet = new Set(session.runIds);
-    const filtered = metas.filter((meta) => runIdSet.has(meta.runId));
-    return {
-      metas: filtered,
-      scopeLabel: sessionId,
-      scopeKind: "session",
-      runIds: session.runIds,
-      warnings,
-      notFound: false
-    };
+  if (opts.durationFilter && !durationMatches(m.durationMs, opts.durationFilter)) {
+    return [];
   }
-  if (groupId) {
-    const runIds = records.filter((run) => extractSessionWorkflowMetadata(run.metadata)?.groupId === groupId).map((run) => run.runId).sort();
-    if (runIds.length === 0) {
-      return {
-        metas: [],
-        scopeLabel: groupId,
-        scopeKind: "group",
-        runIds: [],
-        warnings,
-        notFound: true
-      };
+  const fields = [];
+  if (opts.statusFilter) fields.push("run.status");
+  if (opts.nameQuery) fields.push("run.name");
+  if (opts.durationFilter) fields.push("run.durationMs");
+  if (fields.length === 0) return [];
+  return [
+    {
+      runId: m.runId,
+      runName: m.name,
+      runStatus: m.status,
+      timestamp: m.startedAt,
+      durationMs: m.durationMs,
+      matchReason: `run match: ${fields.join(", ")}`,
+      matchedFields: fields,
+      filePath: m.filePath
     }
-    const runIdSet = new Set(runIds);
-    return {
-      metas: metas.filter((meta) => runIdSet.has(meta.runId)),
-      scopeLabel: groupId,
-      scopeKind: "group",
-      runIds,
-      warnings,
-      notFound: false
-    };
-  }
-  return {
-    metas: [...metas],
-    scopeLabel: "",
-    scopeKind: "session",
-    runIds: [],
-    warnings,
-    notFound: false
-  };
-}
-function traceMetasToSessionRunRecords(metas) {
-  return metas.map(metaToSessionRunRecord);
+  ];
 }
-
-// packages/core/src/sessions/cohort.ts
-function groupSessionCohorts(runs, options = {}) {
-  const groupBy = options.groupBy ?? "session";
-  const cohorts = [];
-  if (groupBy === "session") {
-    const index = buildSessionIndex(runs, options);
-    for (const session of index.sessions) {
-      cohorts.push({
-        key: session.sessionId,
-        kind: "session",
-        runIds: [...session.runIds]
-      });
-    }
-    if (index.unscopedRunIds.length > 0) {
-      cohorts.push({
-        key: "__unscoped__",
-        kind: "session",
-        runIds: [...index.unscopedRunIds]
-      });
+function matchStepLevel(m, events, opts) {
+  const out = [];
+  const started = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.event === "step_started") {
+      started.set(e.stepId, e);
     }
-    return cohorts.sort((a, b) => a.key.localeCompare(b.key));
   }
-  const byGroup = /* @__PURE__ */ new Map();
-  const unscoped = [];
-  for (const run of runs) {
-    const groupId = extractSessionWorkflowMetadata(run.metadata)?.groupId;
-    if (!groupId) {
-      unscoped.push(run.runId);
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const c = e;
+    const s = started.get(c.stepId);
+    if (!s) continue;
+    const fields = [];
+    const stepType = s.type;
+    if (opts.stepTypeFilter && stepType !== opts.stepTypeFilter) {
       continue;
     }
-    const bucket = byGroup.get(groupId) ?? [];
-    bucket.push(run.runId);
-    byGroup.set(groupId, bucket);
-  }
-  for (const [key, runIds] of [...byGroup.entries()].sort(
-    ([a], [b]) => a.localeCompare(b)
-  )) {
-    cohorts.push({
-      key,
-      kind: "group",
-      runIds: runIds.sort()
+    const hasStepFilters = opts.stepTypeFilter || opts.nameQuery || opts.toolQuery || opts.durationFilter || opts.statusFilter === "error" || opts.statusFilter === "success";
+    if (!hasStepFilters) continue;
+    if (opts.statusFilter === "error" && c.status === "error") {
+      fields.push("step.status");
+    } else if (opts.statusFilter === "success" && c.status === "success") {
+      fields.push("step.status");
+    } else if (opts.statusFilter === "error" || opts.statusFilter === "success") {
+      continue;
+    }
+    if (opts.nameQuery) {
+      if (!nameMatches(s.name, opts.nameQuery)) continue;
+      fields.push("step.name");
+    }
+    if (opts.toolQuery) {
+      const toolName2 = typeof s.metadata?.toolName === "string" ? s.metadata.toolName : s.name;
+      if (!nameMatches(toolName2, opts.toolQuery)) continue;
+      fields.push("step.tool");
+    }
+    if (opts.durationFilter) {
+      if (!durationMatches(c.durationMs, opts.durationFilter)) continue;
+      fields.push("step.durationMs");
+    }
+    if (opts.stepTypeFilter) {
+      fields.push("step.type");
+    }
+    if (fields.length === 0) continue;
+    out.push({
+      runId: m.runId,
+      runName: m.name,
+      runStatus: m.status,
+      stepId: c.stepId,
+      stepName: s.name,
+      stepType,
+      timestamp: s.startTime ?? s.timestamp,
+      durationMs: c.durationMs,
+      matchReason: `step match: ${fields.join(", ")}`,
+      matchedFields: fields,
+      filePath: m.filePath
     });
   }
-  if (unscoped.length > 0) {
-    cohorts.push({
-      key: "__unscoped__",
-      kind: "group",
-      runIds: unscoped.sort()
-    });
+  return out;
+}
+async function loadTraceMetadataList(_traceDir, fileNames, getPath) {
+  const metas = [];
+  for (const fileName of fileNames) {
+    try {
+      const filePath = getPath(fileName);
+      const meta = await extractMetadata(filePath);
+      metas.push(meta);
+    } catch {
+    }
   }
-  return cohorts;
+  return metas;
 }
 
-// packages/core/src/sessions/checks.ts
-function emptySummary() {
-  return { passed: 0, failed: 0, warnings: 0, errors: 0, rulesEvaluated: 0 };
+// packages/core/src/sessions/metadata.ts
+function isNonEmptyString3(value) {
+  return typeof value === "string" && value.trim() !== "";
 }
-function mergeSummary(target, source) {
-  return {
-    passed: target.passed + source.passed,
-    failed: target.failed + source.failed,
-    warnings: target.warnings + source.warnings,
-    errors: target.errors + source.errors,
-    rulesEvaluated: target.rulesEvaluated + source.rulesEvaluated
-  };
+function finitePositiveInt(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+    return void 0;
+  }
+  return Math.trunc(value);
 }
-function sessionDiagnostic(code, message) {
-  return { code, message, severity: "error" };
+function extractSessionWorkflowMetadata(record) {
+  if (!record) return void 0;
+  const out = {};
+  let found = false;
+  const assignString = (key, value) => {
+    if (isNonEmptyString3(value)) {
+      out[key] = value.trim();
+      found = true;
+    }
+  };
+  assignString("sessionId", record.sessionId);
+  assignString("conversationId", record.conversationId);
+  assignString("groupId", record.groupId);
+  assignString("parentGroupId", record.parentGroupId);
+  assignString("retryOf", record.retryOf);
+  assignString("retryReason", record.retryReason);
+  assignString("handoffFrom", record.handoffFrom);
+  assignString("handoffTo", record.handoffTo);
+  assignString("subAgentId", record.subAgentId);
+  assignString("subAgentName", record.subAgentName);
+  assignString("jobId", record.jobId);
+  assignString("queueName", record.queueName);
+  assignString("workflowName", record.workflowName);
+  assignString("workflowStep", record.workflowStep);
+  assignString("toolCallId", record.toolCallId);
+  assignString("mcpToolCallId", record.mcpToolCallId);
+  assignString("linkedStepId", record.linkedStepId);
+  assignString("operationId", record.operationId);
+  assignString("attemptId", record.attemptId);
+  assignString("fallbackOf", record.fallbackOf);
+  assignString("idempotencyKey", record.idempotencyKey);
+  assignString("correlationId", record.correlationId);
+  assignString("requestId", record.requestId);
+  assignString("decisionId", record.decisionId);
+  const attempt = finitePositiveInt(record.attempt);
+  if (attempt !== void 0) {
+    out.attempt = attempt;
+    found = true;
+  }
+  const attemptNumber = finitePositiveInt(record.attemptNumber);
+  if (attemptNumber !== void 0) {
+    out.attemptNumber = attemptNumber;
+    found = true;
+  }
+  return found ? out : void 0;
 }
-function aggregateSessionCheckResults(perRun, scope) {
-  if (scope.notFound) {
-    return {
-      ok: false,
-      status: "error",
-      format: perRun[0]?.format ?? "agent-inspect-jsonl",
-      scopeKind: scope.scopeKind,
-      scopeLabel: scope.scopeLabel,
-      runIds: [],
-      runResults: [],
-      summary: { ...emptySummary(), errors: 1 },
-      findings: [],
-      diagnostics: [
-        sessionDiagnostic(
-          "AI_CHECK_INVALID_ARGUMENTS",
-          `${scope.scopeKind} not found: ${scope.scopeLabel}`
-        )
-      ],
-      ruleExecutions: [],
-      ...scope.sessionWarnings?.length ? { sessionWarnings: [...scope.sessionWarnings] } : {}
-    };
+function sessionKeyForRun(meta, options) {
+  if (meta?.sessionId) return meta.sessionId;
+  if (options?.correlateByGroupId && meta?.groupId) {
+    return `group:${meta.groupId}`;
   }
-  if (scope.empty || perRun.length === 0) {
-    return {
-      ok: false,
-      status: "error",
-      format: perRun[0]?.format ?? "agent-inspect-jsonl",
-      scopeKind: scope.scopeKind,
-      scopeLabel: scope.scopeLabel,
-      runIds: scope.runIds,
-      runResults: [],
-      summary: { ...emptySummary(), errors: 1 },
-      findings: [],
-      diagnostics: [
-        sessionDiagnostic(
-          "AI_CHECK_TRACE_UNREADABLE",
-          `No readable traces in ${scope.scopeKind}: ${scope.scopeLabel}`
-        )
-      ],
-      ruleExecutions: [],
-      ...scope.sessionWarnings?.length ? { sessionWarnings: [...scope.sessionWarnings] } : {}
-    };
+  return void 0;
+}
+
+// packages/core/src/sessions/status.ts
+var DEFAULT_STALE_THRESHOLD_MS = 864e5;
+var EXPLICIT_STATUS_PRIORITY = {
+  error: 5,
+  waiting_input: 4,
+  idle: 3,
+  stale: 2,
+  completed: 1
+};
+var EXPLICIT_SESSION_STATUSES = /* @__PURE__ */ new Set([
+  "running",
+  "waiting_input",
+  "idle",
+  "completed",
+  "error",
+  "stale",
+  "unknown"
+]);
+function isExplicitSessionStatus(value) {
+  return typeof value === "string" && EXPLICIT_SESSION_STATUSES.has(value);
+}
+function activityMs(run) {
+  return run.endedAt ?? run.startedAt ?? 0;
+}
+function latestActivityMs(runs) {
+  let latest = 0;
+  for (const run of runs) {
+    const ms = activityMs(run);
+    if (ms > latest) latest = ms;
   }
-  let summary = emptySummary();
-  const findings = [];
-  const diagnostics = [];
-  const ruleExecutions = [];
-  const runResults = [];
-  for (const result of perRun) {
-    summary = mergeSummary(summary, result.summary);
-    findings.push(...result.findings);
-    diagnostics.push(...result.diagnostics);
-    ruleExecutions.push(...result.ruleExecutions ?? []);
-    if (result.runId) {
-      runResults.push({ runId: result.runId, status: result.status });
+  return latest;
+}
+function earliestStart(runs) {
+  let earliest;
+  for (const run of runs) {
+    if (run.startedAt === void 0) continue;
+    if (earliest === void 0 || run.startedAt < earliest) {
+      earliest = run.startedAt;
     }
   }
-  runResults.sort((a, b) => a.runId.localeCompare(b.runId));
-  findings.sort((a, b) => {
-    const runCmp = (a.evidence[0]?.runId ?? "").localeCompare(
-      b.evidence[0]?.runId ?? ""
-    );
-    if (runCmp !== 0) return runCmp;
-    return a.ruleId.localeCompare(b.ruleId);
-  });
-  ruleExecutions.sort((a, b) => {
-    const runCmp = (a.runId ?? "").localeCompare(b.runId ?? "");
-    if (runCmp !== 0) return runCmp;
-    return a.ruleId.localeCompare(b.ruleId);
-  });
-  const hasErrors = diagnostics.some((item) => item.severity === "error");
-  const status = hasErrors ? "error" : summary.failed > 0 ? "fail" : "pass";
-  return {
-    ok: status === "pass",
-    status,
-    format: perRun[0]?.format ?? "agent-inspect-jsonl",
-    scopeKind: scope.scopeKind,
-    scopeLabel: scope.scopeLabel,
-    runIds: scope.runIds,
-    runResults,
-    summary,
-    findings,
-    diagnostics,
-    ruleExecutions,
-    ...scope.sessionWarnings?.length ? { sessionWarnings: [...scope.sessionWarnings] } : {}
-  };
+  return earliest;
 }
-
-// packages/core/src/sessions/index.ts
-function compareRuns(a, b) {
-  const aStart = a.startedAt ?? 0;
-  const bStart = b.startedAt ?? 0;
-  if (aStart !== bStart) return aStart - bStart;
-  return a.runId.localeCompare(b.runId);
+function latestEndWhenAllEnded(runs) {
+  if (runs.length === 0) return void 0;
+  let latest;
+  for (const run of runs) {
+    if (run.endedAt === void 0) return void 0;
+    if (latest === void 0 || run.endedAt > latest) latest = run.endedAt;
+  }
+  return latest;
 }
-function buildGroups(runIds, metaByRunId) {
-  const byGroup = /* @__PURE__ */ new Map();
-  for (const runId of runIds) {
-    const groupId = metaByRunId.get(runId)?.groupId;
-    if (!groupId) continue;
-    const existing = byGroup.get(groupId);
-    if (existing) {
-      existing.runIds.push(runId);
-    } else {
-      byGroup.set(groupId, {
-        groupId,
-        parentGroupId: metaByRunId.get(runId)?.parentGroupId,
-        runIds: [runId]
-      });
+function pickExplicitStatus(runs) {
+  let best;
+  let bestPriority = 0;
+  for (const run of runs) {
+    const raw = run.metadata?.sessionStatus;
+    if (!isExplicitSessionStatus(raw)) continue;
+    const priority = EXPLICIT_STATUS_PRIORITY[raw] ?? 0;
+    if (priority > bestPriority) {
+      bestPriority = priority;
+      best = raw;
     }
   }
-  return [...byGroup.values()].map((group) => ({
-    ...group,
-    runIds: [...group.runIds].sort((a, b) => a.localeCompare(b))
-  }));
+  return best;
 }
-function buildHandoffs(runIds, metaByRunId, warnings, sessionId) {
-  const edges = [];
-  const seen = /* @__PURE__ */ new Set();
-  const pushEdge = (edge) => {
-    const key = `${edge.from}->${edge.to}:${edge.confidence}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    edges.push(edge);
-  };
-  for (const runId of runIds) {
-    const meta = metaByRunId.get(runId);
-    if (!meta) continue;
-    if (meta.handoffFrom && meta.handoffTo) {
-      pushEdge({
-        from: meta.handoffFrom,
-        to: meta.handoffTo,
-        source: "manual",
-        confidence: "explicit"
-      });
-      continue;
+function deriveLastError(runs) {
+  const errorRuns = runs.filter((run) => run.status === "error").sort((a, b) => activityMs(b) - activityMs(a));
+  const latest = errorRuns[0];
+  if (!latest) return void 0;
+  const meta = latest.metadata ?? {};
+  const message = typeof meta.errorMessage === "string" && meta.errorMessage.trim() !== "" ? meta.errorMessage.trim() : latest.name ?? latest.runId;
+  const code = typeof meta.errorCode === "string" && meta.errorCode.trim() !== "" ? meta.errorCode.trim() : void 0;
+  return { runId: latest.runId, message, code };
+}
+function deriveCheckSummary(runs) {
+  let pass = 0;
+  let fail = 0;
+  let warn2 = 0;
+  let found = false;
+  for (const run of runs) {
+    const summary = run.metadata?.checkSummary;
+    if (!summary || typeof summary !== "object") continue;
+    const record = summary;
+    if (typeof record.pass === "number") {
+      pass += record.pass;
+      found = true;
     }
-    if (meta.handoffFrom) {
-      pushEdge({
-        from: meta.handoffFrom,
-        to: runId,
-        source: "manual",
-        confidence: "explicit"
-      });
+    if (typeof record.fail === "number") {
+      fail += record.fail;
+      found = true;
     }
-    if (meta.handoffTo) {
-      pushEdge({
-        from: runId,
-        to: meta.handoffTo,
-        source: "manual",
-        confidence: "explicit"
-      });
+    if (typeof record.warn === "number") {
+      warn2 += record.warn;
+      found = true;
     }
-    if (meta.subAgentId && meta.parentGroupId && !meta.handoffFrom && !meta.handoffTo) {
-      pushEdge({
-        from: meta.parentGroupId,
-        to: meta.subAgentId,
-        source: "inferred",
-        confidence: "correlated"
-      });
-      warnings.push({
-        code: "ambiguous-handoff-endpoints",
-        message: "Handoff inferred from parentGroupId and subAgentId without explicit handoffFrom/handoffTo.",
-        runId,
-        sessionId
-      });
+  }
+  return found ? { pass, fail, warn: warn2 } : void 0;
+}
+function deriveObservationSummary(runs) {
+  for (const run of [...runs].sort((a, b) => activityMs(b) - activityMs(a))) {
+    const value = run.metadata?.observationSummary;
+    if (typeof value === "string" && value.trim() !== "") {
+      return value.trim();
     }
   }
-  return edges.sort((a, b) => {
-    const from = a.from.localeCompare(b.from);
-    if (from !== 0) return from;
-    return a.to.localeCompare(b.to);
-  });
+  return void 0;
 }
-function buildRetries(runIds, metaByRunId, warnings, sessionId) {
-  const retries = [];
-  for (const runId of runIds) {
-    const meta = metaByRunId.get(runId);
-    if (!meta) continue;
-    if (meta.retryOf) {
-      retries.push({
-        runId,
-        retryOf: meta.retryOf,
-        attempt: meta.attempt,
-        source: "manual",
-        confidence: "explicit"
-      });
-      continue;
-    }
-    if (meta.attempt !== void 0 && meta.attempt > 1) {
-      retries.push({
-        runId,
-        attempt: meta.attempt,
-        source: "inferred",
-        confidence: "correlated"
-      });
-      warnings.push({
-        code: "ambiguous-retry-link",
-        message: "attempt > 1 without retryOf; retry link is correlated only.",
-        runId,
-        sessionId
-      });
-    }
-  }
-  return retries.sort((a, b) => a.runId.localeCompare(b.runId));
+function deriveSessionStatus(runs, options = {}) {
+  if (runs.length === 0) return "unknown";
+  if (runs.some((run) => run.status === "running")) return "running";
+  const explicit = pickExplicitStatus(runs);
+  if (explicit && explicit !== "running") return explicit;
+  if (runs.some((run) => run.status === "error")) return "error";
+  if (runs.every((run) => run.status === "success")) return "completed";
+  const nowMs = options.nowMs ?? Date.now();
+  const staleThresholdMs = options.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
+  const lastMs = latestActivityMs(runs);
+  if (lastMs > 0 && nowMs - lastMs > staleThresholdMs) return "stale";
+  return "unknown";
 }
-function buildCriticalPath(runs, handoffs) {
-  const runById = new Map(runs.map((run) => [run.runId, run]));
-  const explicitTargets = new Set(
-    handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.to)
-  );
-  const explicitSources = new Set(
-    handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.from)
-  );
-  const ordered = [...runs].sort(compareRuns);
-  const path14 = [];
-  const visited = /* @__PURE__ */ new Set();
-  const pushRun = (run, confidence, source) => {
-    if (visited.has(run.runId)) return;
-    visited.add(run.runId);
-    path14.push({
-      runId: run.runId,
-      name: run.name,
-      startedAt: run.startedAt,
-      durationMs: run.durationMs,
-      confidence,
-      source
-    });
+function enrichSessionSummary(summary, runs, options = {}) {
+  const sessionRuns = runs.filter((run) => summary.runIds.includes(run.runId)).sort((a, b) => a.runId.localeCompare(b.runId));
+  const startedAt = earliestStart(sessionRuns);
+  const endedAt = latestEndWhenAllEnded(sessionRuns);
+  const durationMs2 = startedAt !== void 0 && endedAt !== void 0 ? endedAt - startedAt : void 0;
+  let correlationId;
+  let jobId;
+  let workflowId;
+  for (const run of sessionRuns) {
+    const meta = extractSessionWorkflowMetadata(run.metadata);
+    if (!correlationId && meta?.correlationId) correlationId = meta.correlationId;
+    if (!jobId && meta?.jobId) jobId = meta.jobId;
+    if (!workflowId && meta?.workflowName) workflowId = meta.workflowName;
+    else if (!workflowId && meta?.workflowStep) workflowId = meta.workflowStep;
+  }
+  const lastMs = latestActivityMs(sessionRuns);
+  const lastActivity = lastMs > 0 ? new Date(lastMs).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
+  const retryCount2 = summary.retries.filter(
+    (retry) => retry.retryOf !== void 0 || (retry.attempt ?? 0) > 1
+  ).length;
+  return {
+    ...summary,
+    status: deriveSessionStatus(sessionRuns, options),
+    startedAt,
+    endedAt,
+    durationMs: durationMs2,
+    correlationId,
+    jobId,
+    workflowId,
+    lastError: deriveLastError(sessionRuns),
+    lastActivity,
+    retryCount: retryCount2,
+    observationSummary: deriveObservationSummary(sessionRuns),
+    checkSummary: deriveCheckSummary(sessionRuns)
   };
-  for (const edge of handoffs) {
-    if (edge.confidence !== "explicit") continue;
-    const fromRun = [...runById.values()].find(
-      (run) => run.runId === edge.from || metaRunIdMatches(run, edge.from, runById)
-    );
-    const toRun = [...runById.values()].find(
-      (run) => run.runId === edge.to || metaRunIdMatches(run, edge.to, runById)
-    );
-    if (fromRun) pushRun(fromRun, "explicit", "manual");
-    if (toRun) pushRun(toRun, "explicit", "manual");
+}
+
+// packages/core/src/sessions/activity.ts
+function statusLine(session) {
+  const name = session.workflowId ?? session.correlationId ?? session.sessionId;
+  const status = session.status;
+  if (session.lastError) {
+    return `${name} session ${session.sessionId} failed at ${session.lastError.message}`;
   }
-  for (const run of ordered) {
-    if (visited.has(run.runId)) continue;
-    const confidence = explicitTargets.has(run.runId) || explicitSources.has(run.runId) ? "explicit" : "correlated";
-    pushRun(run, confidence, confidence === "explicit" ? "manual" : "inferred");
+  if (session.observationSummary) {
+    return `${name} session ${session.sessionId} ${status} with observation warning`;
   }
-  return path14;
+  return `${name} session ${session.sessionId} ${status}`;
 }
-function metaRunIdMatches(run, token, runById) {
-  const meta = extractSessionWorkflowMetadata(run.metadata);
-  return meta?.subAgentId === token || meta?.groupId === token || runById.has(token);
+function parseSinceMs(since, nowMs) {
+  if (!since || since.trim() === "") return nowMs - 7 * 864e5;
+  const trimmed = since.trim().toLowerCase();
+  const match = /^(\d+)([smhd])$/.exec(trimmed);
+  if (!match) return nowMs - 7 * 864e5;
+  const amount = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  const mult = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return nowMs - amount * mult;
 }
-function buildSessionIndex(inputRuns, options = {}) {
-  const warnings = [];
-  const runs = [...inputRuns].sort(compareRuns);
-  const metaByRunId = /* @__PURE__ */ new Map();
-  for (const run of runs) {
-    metaByRunId.set(run.runId, extractSessionWorkflowMetadata(run.metadata));
-  }
-  const sessionsByKey = /* @__PURE__ */ new Map();
-  const unscopedRunIds = [];
-  for (const run of runs) {
-    const meta = metaByRunId.get(run.runId);
-    const key = sessionKeyForRun(meta, {
-      correlateByGroupId: options.correlateByGroupId === true
-    });
-    if (!key) {
-      unscopedRunIds.push(run.runId);
-      continue;
-    }
-    const bucket = sessionsByKey.get(key) ?? [];
-    bucket.push(run);
-    sessionsByKey.set(key, bucket);
-  }
-  const sessions = [...sessionsByKey.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([sessionId, sessionRuns]) => {
-    const runIds = sessionRuns.map((run) => run.runId).sort();
-    const handoffs = buildHandoffs(runIds, metaByRunId, warnings, sessionId);
-    const retries = buildRetries(runIds, metaByRunId, warnings, sessionId);
-    const groups = buildGroups(runIds, metaByRunId);
-    const criticalPath = buildCriticalPath(sessionRuns, handoffs);
-    const confidences = new Set(handoffs.map((edge) => edge.confidence));
-    if (confidences.has("explicit") && confidences.has("correlated")) {
-      warnings.push({
-        code: "mixed-confidence-group",
-        message: "Session aggregates explicit and correlated handoff edges.",
-        sessionId
-      });
-    }
-    return enrichSessionSummary(
-      {
-        sessionId,
-        runIds,
-        groups,
-        handoffs,
-        retries,
-        criticalPath
-      },
-      runs,
-      {
-        nowMs: options.nowMs,
-        staleThresholdMs: options.staleThresholdMs
-      }
-    );
+function isFailed(status) {
+  return status === "error";
+}
+function isStale(status) {
+  return status === "stale";
+}
+function guardrailWarnings(session) {
+  const summary = session.checkSummary;
+  if (!summary) return 0;
+  return summary.warn;
+}
+function buildActivitySummary(index, options = {}) {
+  const nowMs = options.nowMs ?? Date.now();
+  const sinceMs = parseSinceMs(options.since, nowMs);
+  const sinceIso = new Date(sinceMs).toISOString();
+  const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : 20;
+  const inWindow = index.sessions.filter((session) => {
+    const activityMs2 = Date.parse(session.lastActivity);
+    return Number.isFinite(activityMs2) && activityMs2 >= sinceMs;
   });
-  if (sessions.length === 0 && runs.length > 0) {
-    warnings.push({
-      code: "missing-session-id",
-      message: "No sessionId (or correlated groupId) found on input runs."
-    });
+  const entries = [...inWindow].sort((a, b) => Date.parse(b.lastActivity) - Date.parse(a.lastActivity)).slice(0, limit).map((session) => ({
+    sessionId: session.sessionId,
+    status: session.status,
+    summary: statusLine(session),
+    lastActivity: session.lastActivity,
+    runCount: session.runIds.length
+  }));
+  let failed = 0;
+  let stale = 0;
+  let guardrailWarningTotal = 0;
+  for (const session of inWindow) {
+    if (isFailed(session.status)) failed += 1;
+    if (isStale(session.status)) stale += 1;
+    guardrailWarningTotal += guardrailWarnings(session);
   }
-  warnings.sort((a, b) => {
-    const code = a.code.localeCompare(b.code);
-    if (code !== 0) return code;
-    return (a.runId ?? "").localeCompare(b.runId ?? "");
-  });
   return {
-    runs,
-    sessions,
-    unscopedRunIds: unscopedRunIds.sort(),
-    warnings
+    since: sinceIso,
+    sessions: inWindow.length,
+    failed,
+    stale,
+    guardrailWarnings: guardrailWarningTotal,
+    entries
   };
 }
-var KNOWN_EVENTS = /* @__PURE__ */ new Set([
-  "run_started",
-  "run_completed",
-  "step_started",
-  "step_completed"
-]);
-function isRecord7(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function safeParse(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    return void 0;
-  }
-}
-async function isAgentInspectTrace(filePath) {
-  try {
-    const rl = readline.createInterface({
-      input: fs.createReadStream(filePath, { encoding: "utf8" }),
-      crlfDelay: Infinity
-    });
-    let checked = 0;
-    for await (const line of rl) {
-      const trimmed = line.trim();
-      if (trimmed === "") continue;
-      const parsed = safeParse(trimmed);
-      if (!parsed) continue;
-      if (!isRecord7(parsed)) continue;
-      checked += 1;
-      if (isTraceEvent(parsed)) return true;
-      const ev = parsed.event;
-      const runId = parsed.runId;
-      if (typeof ev === "string" && KNOWN_EVENTS.has(ev) && typeof runId === "string") {
-        return true;
-      }
-      if (checked >= 20) break;
+function renderActivitySummaryHuman(summary, options) {
+  const lines = [];
+  const nowMs = options?.nowMs ?? Date.now();
+  const todayStart = new Date(nowMs);
+  todayStart.setHours(0, 0, 0, 0);
+  const todayMs = todayStart.getTime();
+  const today = summary.entries.filter(
+    (entry) => Date.parse(entry.lastActivity) >= todayMs
+  );
+  if (today.length > 0) {
+    lines.push("Today");
+    for (const entry of today) {
+      lines.push(`  ${entry.summary}`);
     }
-    return false;
-  } catch {
-    return false;
+    lines.push("");
   }
+  lines.push(`Since ${summary.since}`);
+  lines.push(`  ${summary.sessions} sessions`);
+  lines.push(`  ${summary.failed} failed`);
+  lines.push(`  ${summary.stale} stale`);
+  lines.push(`  ${summary.guardrailWarnings} guardrail warnings`);
+  return lines.join("\n");
 }
 
-// packages/core/src/bundle/resolve.ts
-function parseSinceCutoff(since) {
-  const trimmed = since.trim();
-  if (trimmed === "") {
-    throw new Error("--since requires a non-empty duration (e.g. 24h, 7d).");
+// packages/core/src/sessions/types.ts
+var SESSION_WORKFLOW_KEYS = [
+  "sessionId",
+  "conversationId",
+  "groupId",
+  "parentGroupId",
+  "attempt",
+  "retryOf",
+  "retryReason",
+  "handoffFrom",
+  "handoffTo",
+  "subAgentId",
+  "subAgentName",
+  "jobId",
+  "queueName",
+  "workflowName",
+  "workflowStep",
+  "toolCallId",
+  "mcpToolCallId",
+  "linkedStepId",
+  "operationId",
+  "attemptId",
+  "attemptNumber",
+  "fallbackOf",
+  "idempotencyKey",
+  "correlationId",
+  "requestId",
+  "decisionId"
+];
+
+// packages/core/src/sessions/load.ts
+async function enrichSessionRunRecord(meta) {
+  let metadata;
+  try {
+    const events = await readTraceEventsFromFile(meta.filePath);
+    for (const event of events) {
+      if (event.event !== "run_started") continue;
+      if (event.metadata && typeof event.metadata === "object") {
+        metadata = event.metadata;
+      }
+      break;
+    }
+  } catch {
   }
-  return Date.now() - parseDuration(trimmed);
-}
-function runActivityMs(run) {
-  if (run.startedAt !== void 0 && Number.isFinite(run.startedAt)) return run.startedAt;
-  if (run.endedAt !== void 0 && Number.isFinite(run.endedAt)) return run.endedAt;
-  return void 0;
+  return {
+    runId: meta.runId,
+    name: meta.name,
+    status: meta.status,
+    startedAt: meta.startedAt,
+    endedAt: meta.endedAt,
+    durationMs: meta.durationMs,
+    filePath: meta.filePath,
+    metadata
+  };
 }
-function runsInSinceWindow(runs, since) {
-  const cutoff = parseSinceCutoff(since);
-  const ids = [];
-  for (const run of runs) {
-    const activity = runActivityMs(run);
-    if (activity !== void 0 && activity >= cutoff) {
-      ids.push(run.runId);
-    }
+async function loadSessionRunRecords(metas) {
+  const out = [];
+  for (const meta of metas) {
+    out.push(await enrichSessionRunRecord(meta));
   }
-  return ids.sort((a, b) => a.localeCompare(b));
+  return out;
 }
-function findSession(index, sessionId) {
-  return index.sessions.find((session) => session.sessionId === sessionId);
+
+// packages/core/src/sessions/scope.ts
+function metaToSessionRunRecord(meta) {
+  return {
+    runId: meta.runId,
+    name: meta.name,
+    status: meta.status,
+    startedAt: meta.startedAt,
+    endedAt: meta.endedAt,
+    durationMs: meta.durationMs,
+    filePath: meta.filePath,
+    metadata: void 0
+  };
 }
-function resolveBundleRunIds(index, runs, options) {
-  const runId = options.runId?.trim();
+function filterMetasBySessionScope(metas, records, options) {
   const sessionId = options.sessionId?.trim();
-  const since = options.since?.trim();
-  const modes = [runId ? 1 : 0, sessionId ? 1 : 0, since ? 1 : 0].reduce((a, b) => a + b, 0);
-  if (modes === 0) {
-    throw new Error(
-      "bundle requires a run id, --session <sessionId>, or --since <duration>."
-    );
-  }
-  if (modes > 1) {
-    throw new Error(
-      "bundle accepts only one target: a run id, --session, or --since (not combined)."
-    );
-  }
-  if (runId) {
-    const known = runs.some((run) => run.runId === runId);
-    if (!known) {
-      throw new Error(`Run "${runId}" was not found in the trace directory.`);
-    }
-    return { runIds: [runId] };
-  }
+  const groupId = options.groupId?.trim();
+  const warnings = [];
   if (sessionId) {
-    const session = findSession(index, sessionId);
+    const index = buildSessionIndex(records, {
+      correlateByGroupId: options.correlateByGroupId === true
+    });
+    warnings.push(...index.warnings);
+    const session = index.sessions.find((item) => item.sessionId === sessionId);
     if (!session) {
-      throw new Error(`Session "${sessionId}" was not found.`);
-    }
-    if (session.runIds.length === 0) {
-      throw new Error(`Session "${sessionId}" has no runs to bundle.`);
+      return {
+        metas: [],
+        scopeLabel: sessionId,
+        scopeKind: "session",
+        runIds: [],
+        warnings,
+        notFound: true
+      };
     }
+    const runIdSet = new Set(session.runIds);
+    const filtered = metas.filter((meta) => runIdSet.has(meta.runId));
     return {
-      runIds: [...session.runIds].sort((a, b) => a.localeCompare(b)),
-      sessionId
+      metas: filtered,
+      scopeLabel: sessionId,
+      scopeKind: "session",
+      runIds: session.runIds,
+      warnings,
+      notFound: false
     };
   }
-  const runIds = runsInSinceWindow(runs, since);
-  if (runIds.length === 0) {
-    throw new Error(`No runs matched --since ${since}.`);
+  if (groupId) {
+    const runIds = records.filter((run) => extractSessionWorkflowMetadata(run.metadata)?.groupId === groupId).map((run) => run.runId).sort();
+    if (runIds.length === 0) {
+      return {
+        metas: [],
+        scopeLabel: groupId,
+        scopeKind: "group",
+        runIds: [],
+        warnings,
+        notFound: true
+      };
+    }
+    const runIdSet = new Set(runIds);
+    return {
+      metas: metas.filter((meta) => runIdSet.has(meta.runId)),
+      scopeLabel: groupId,
+      scopeKind: "group",
+      runIds,
+      warnings,
+      notFound: false
+    };
   }
-  return { runIds, since };
-}
-
-// packages/core/src/bundle/safety-status.ts
-function aggregateBundleSafeStatus(statuses) {
-  if (statuses.length === 0) return "UNKNOWN";
-  if (statuses.some((status) => status === "UNSAFE")) return "UNSAFE";
-  if (statuses.some((status) => status === "UNKNOWN")) return "UNKNOWN";
-  if (statuses.some((status) => status === "SAFE WITH WARNINGS")) return "SAFE WITH WARNINGS";
-  return "SAFE";
-}
-function toMetadataSafeStatus(status) {
-  if (status === "SAFE WITH WARNINGS") return "SAFE_WITH_WARNINGS";
-  return status;
-}
-function bundleFailsOnSafety(status, allowUnsafe) {
-  if (allowUnsafe) return false;
-  return status === "UNSAFE" || status === "UNKNOWN";
-}
-
-// packages/core/src/bundle/manifest.ts
-var BUNDLE_NOTE = "Generated locally by AgentInspect. Bundles are derived copies for review \u2014 not compliance or security certification. Review before sharing.";
-var PLACEHOLDER_NOTE = "No eval or performance artifacts were requested for this bundle.";
-function buildBundleMetadata(parts) {
-  const aggregate = aggregateBundleSafeStatus(
-    parts.checks.runs.map((run) => run.status)
-  );
   return {
-    createdAt: parts.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-    agentInspectVersion: parts.agentInspectVersion,
-    redactionProfile: parts.profile,
-    sourceTraceCount: parts.resolve.runIds.length,
-    runIds: [...parts.resolve.runIds],
-    safeStatus: toMetadataSafeStatus(aggregate),
-    files: [...parts.files].sort((a, b) => a.localeCompare(b)),
-    note: BUNDLE_NOTE,
-    ...parts.resolve.sessionId !== void 0 ? { sessionId: parts.resolve.sessionId } : {},
-    ...parts.resolve.since !== void 0 ? { since: parts.resolve.since } : {}
+    metas: [...metas],
+    scopeLabel: "",
+    scopeKind: "session",
+    runIds: [],
+    warnings,
+    notFound: false
   };
 }
-function buildPlaceholderArtifact() {
-  return {
-    status: "not_requested",
-    note: PLACEHOLDER_NOTE
-  };
+function traceMetasToSessionRunRecords(metas) {
+  return metas.map(metaToSessionRunRecord);
 }
 
-// packages/core/src/bundle/summary.ts
-function markdownTable(rows) {
-  const lines = ["| Field | Value |", "| --- | --- |"];
-  for (const [key, value] of rows) {
-    lines.push(`| ${key} | ${value ?? "unknown"} |`);
-  }
-  return lines.join("\n");
-}
-function buildBundleSummaryMarkdown(parts) {
-  const { metadata, checks, redaction } = parts;
-  const lines = [
-    "# AgentInspect trace bundle",
-    "",
-    metadata.note,
-    "",
-    "## Overview",
-    "",
-    markdownTable([
-      ["Created", metadata.createdAt],
-      ["AgentInspect", metadata.agentInspectVersion],
-      ["Redaction profile", metadata.redactionProfile],
-      ["Safe status", metadata.safeStatus],
-      ["Source traces", metadata.sourceTraceCount],
-      ["Runs", metadata.runIds.join(", ")],
-      ...metadata.sessionId ? [["Session", metadata.sessionId]] : [],
-      ...metadata.since ? [["Since", metadata.since]] : []
-    ]),
-    "",
-    "## Safety checks",
-    "",
-    `Aggregate: **${checks.aggregateStatus}**`,
-    ""
-  ];
-  for (const run of checks.runs) {
-    const source = run.sourceStatus !== void 0 && run.sourceStatus !== run.status ? `; source ${run.sourceStatus}` : "";
-    lines.push(
-      `- \`${run.runId}\`: artifact ${run.status}${source} (${run.findings} finding(s), ${run.errors} error(s), ${run.warnings} warning(s))`
-    );
-  }
-  lines.push("", "## Redaction", "", `Total findings: ${redaction.totalFindings}`, "");
-  for (const run of redaction.runs) {
-    const detectors = run.detectors.length > 0 ? run.detectors.join(", ") : "none";
-    lines.push(`- \`${run.runId}\`: ${run.findings} finding(s); detectors: ${detectors}`);
-  }
-  lines.push(
-    "",
-    "## Files",
-    "",
-    ...metadata.files.map((file) => `- \`${file}\``),
-    "",
-    "_Review every generated artifact before sharing outside your team._",
-    ""
-  );
-  return lines.join("\n");
-}
-function sanitizeBundleRunId(runId) {
-  let safe = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "run_unknown";
-  safe = path7__default.default.basename(safe);
-  safe = safe.replace(/[^a-zA-Z0-9._-]+/g, "_");
-  if (safe === "" || safe === "." || safe === "..") {
-    safe = "run_unknown";
+// packages/core/src/sessions/cohort.ts
+function groupSessionCohorts(runs, options = {}) {
+  const groupBy = options.groupBy ?? "session";
+  const cohorts = [];
+  if (groupBy === "session") {
+    const index = buildSessionIndex(runs, options);
+    for (const session of index.sessions) {
+      cohorts.push({
+        key: session.sessionId,
+        kind: "session",
+        runIds: [...session.runIds]
+      });
+    }
+    if (index.unscopedRunIds.length > 0) {
+      cohorts.push({
+        key: "__unscoped__",
+        kind: "session",
+        runIds: [...index.unscopedRunIds]
+      });
+    }
+    return cohorts.sort((a, b) => a.key.localeCompare(b.key));
   }
-  return safe;
-}
-function bundleRunAssetRelativePath(runId, extension) {
-  const safe = sanitizeBundleRunId(runId);
-  const ext = extension.startsWith(".") ? extension : `.${extension}`;
-  return path7__default.default.posix.join("assets", "runs", `${safe}${ext}`);
-}
-function assertBundlePathContained(outputDir, relativePath) {
-  const base = path7__default.default.resolve(outputDir);
-  const resolved = path7__default.default.resolve(base, relativePath);
-  if (resolved !== base && !resolved.startsWith(base + path7__default.default.sep)) {
-    throw new Error(`Bundle path escapes output directory: ${relativePath}`);
+  const byGroup = /* @__PURE__ */ new Map();
+  const unscoped = [];
+  for (const run of runs) {
+    const groupId = extractSessionWorkflowMetadata(run.metadata)?.groupId;
+    if (!groupId) {
+      unscoped.push(run.runId);
+      continue;
+    }
+    const bucket = byGroup.get(groupId) ?? [];
+    bucket.push(run.runId);
+    byGroup.set(groupId, bucket);
   }
-  return resolved;
-}
-function normalizeBundleOutputPath(out, options) {
-  const trimmed = out.trim();
-  if (trimmed === "") {
-    throw new Error("--out requires a non-empty path.");
+  for (const [key, runIds] of [...byGroup.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    cohorts.push({
+      key,
+      kind: "group",
+      runIds: runIds.sort()
+    });
   }
-  const resolved = path7__default.default.resolve(trimmed);
-  if (options?.preserveZipExtension !== true && resolved.toLowerCase().endsWith(".zip")) {
-    return resolved.slice(0, -4);
+  if (unscoped.length > 0) {
+    cohorts.push({
+      key: "__unscoped__",
+      kind: "group",
+      runIds: unscoped.sort()
+    });
   }
-  return resolved;
-}
-function defaultBundleOutputPath(runIds) {
-  const label = runIds.length === 1 ? sanitizeBundleRunId(runIds[0]) : `multi-${runIds.length}`;
-  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return path7__default.default.resolve(`agent-inspect-bundle-${label}-${stamp}`);
+  return cohorts;
 }
 
-// packages/core/src/evidence/types.ts
-var EVIDENCE_FORMAT_VERSION = "1.0";
-var EVIDENCE_ASSESSMENT_NOTE = "Best-effort local safety verification only; not a compliance certification.";
-var EVIDENCE_MANIFEST_FILENAME = "evidence.json";
-var EVIDENCE_RESOLVED_CONTRACT_FILENAME = "contract.resolved.json";
-var SHA256_RE = /^[a-f0-9]{64}$/i;
-function sha256Hex(data) {
-  const hash = crypto.createHash("sha256");
-  if (typeof data === "string") {
-    hash.update(data, "utf8");
-  } else {
-    hash.update(data);
-  }
-  return hash.digest("hex");
+// packages/core/src/sessions/checks.ts
+function emptySummary() {
+  return {
+    passed: 0,
+    failed: 0,
+    warnings: 0,
+    errors: 0,
+    rulesEvaluated: 0,
+    rulesPassed: 0,
+    rulesWarning: 0,
+    rulesFailed: 0,
+    rulesError: 0
+  };
 }
-function isSha256Hex(value) {
-  return SHA256_RE.test(value);
+function mergeSummary(target, source) {
+  return {
+    passed: target.passed + source.passed,
+    failed: target.failed + source.failed,
+    warnings: target.warnings + source.warnings,
+    errors: target.errors + source.errors,
+    rulesEvaluated: target.rulesEvaluated + source.rulesEvaluated,
+    rulesPassed: target.rulesPassed + source.rulesPassed,
+    rulesWarning: target.rulesWarning + source.rulesWarning,
+    rulesFailed: target.rulesFailed + source.rulesFailed,
+    rulesError: target.rulesError + source.rulesError
+  };
 }
-function sha256Equals(expected, actual) {
-  if (!isSha256Hex(expected) || !isSha256Hex(actual)) {
-    return false;
-  }
-  const a = expected.toLowerCase();
-  const b = actual.toLowerCase();
-  if (a.length !== b.length) return false;
-  let mismatch = 0;
-  for (let i = 0; i < a.length; i += 1) {
-    mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
-  }
-  return mismatch === 0;
+function sessionDiagnostic(code, message) {
+  return { code, message, severity: "error" };
 }
-function assertEvidenceRelativePath(relativePath) {
-  if (typeof relativePath !== "string" || relativePath.trim() === "") {
-    throw new Error("Evidence file path must be a non-empty relative path.");
-  }
-  const trimmed = relativePath.trim().replaceAll("\\", "/");
-  if (path7__default.default.isAbsolute(trimmed) || trimmed.startsWith("/")) {
-    throw new Error(`Evidence file path must be relative: ${relativePath}`);
+function aggregateSessionCheckResults(perRun, scope) {
+  if (scope.notFound) {
+    return {
+      ok: false,
+      status: "error",
+      format: perRun[0]?.format ?? "agent-inspect-jsonl",
+      scopeKind: scope.scopeKind,
+      scopeLabel: scope.scopeLabel,
+      runIds: [],
+      runResults: [],
+      summary: { ...emptySummary(), errors: 1 },
+      findings: [],
+      diagnostics: [
+        sessionDiagnostic(
+          "AI_CHECK_INVALID_ARGUMENTS",
+          `${scope.scopeKind} not found: ${scope.scopeLabel}`
+        )
+      ],
+      ruleExecutions: [],
+      ...scope.sessionWarnings?.length ? { sessionWarnings: [...scope.sessionWarnings] } : {}
+    };
   }
-  const parts = trimmed.split("/").filter((part) => part !== "");
-  if (parts.length === 0) {
-    throw new Error(`Evidence file path must be relative: ${relativePath}`);
+  if (scope.empty || perRun.length === 0) {
+    return {
+      ok: false,
+      status: "error",
+      format: perRun[0]?.format ?? "agent-inspect-jsonl",
+      scopeKind: scope.scopeKind,
+      scopeLabel: scope.scopeLabel,
+      runIds: scope.runIds,
+      runResults: [],
+      summary: { ...emptySummary(), errors: 1 },
+      findings: [],
+      diagnostics: [
+        sessionDiagnostic(
+          "AI_CHECK_TRACE_UNREADABLE",
+          `No readable traces in ${scope.scopeKind}: ${scope.scopeLabel}`
+        )
+      ],
+      ruleExecutions: [],
+      ...scope.sessionWarnings?.length ? { sessionWarnings: [...scope.sessionWarnings] } : {}
+    };
   }
-  for (const part of parts) {
-    if (part === "." || part === "..") {
-      throw new Error(`Evidence file path must not contain "." or "..": ${relativePath}`);
+  let summary = emptySummary();
+  const findings = [];
+  const diagnostics = [];
+  const ruleExecutions = [];
+  const runResults = [];
+  for (const result of perRun) {
+    summary = mergeSummary(summary, result.summary);
+    findings.push(...result.findings);
+    diagnostics.push(...result.diagnostics);
+    ruleExecutions.push(...result.ruleExecutions ?? []);
+    if (result.runId) {
+      runResults.push({ runId: result.runId, status: result.status });
     }
   }
-  return parts.join("/");
-}
-
-// packages/core/src/evidence/manifest.ts
-function stable(value) {
-  if (Array.isArray(value)) return value.map(stable);
-  if (value === null || typeof value !== "object") return value;
-  const record = value;
-  return Object.fromEntries(
-    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable(record[key])])
-  );
+  runResults.sort((a, b) => a.runId.localeCompare(b.runId));
+  findings.sort((a, b) => {
+    const runCmp = (a.evidence[0]?.runId ?? "").localeCompare(
+      b.evidence[0]?.runId ?? ""
+    );
+    if (runCmp !== 0) return runCmp;
+    return a.ruleId.localeCompare(b.ruleId);
+  });
+  ruleExecutions.sort((a, b) => {
+    const runCmp = (a.runId ?? "").localeCompare(b.runId ?? "");
+    if (runCmp !== 0) return runCmp;
+    return a.ruleId.localeCompare(b.ruleId);
+  });
+  const hasErrors = diagnostics.some((item) => item.severity === "error");
+  const status = hasErrors ? "error" : summary.failed > 0 ? "fail" : "pass";
+  return {
+    ok: status === "pass",
+    status,
+    format: perRun[0]?.format ?? "agent-inspect-jsonl",
+    scopeKind: scope.scopeKind,
+    scopeLabel: scope.scopeLabel,
+    runIds: scope.runIds,
+    runResults,
+    summary,
+    findings,
+    diagnostics,
+    ruleExecutions,
+    ...scope.sessionWarnings?.length ? { sessionWarnings: [...scope.sessionWarnings] } : {}
+  };
 }
-function serializeEvidenceManifest(manifest) {
-  return `${JSON.stringify(stable(manifest), null, 2)}
-`;
+
+// packages/core/src/sessions/index.ts
+function compareRuns(a, b) {
+  const aStart = a.startedAt ?? 0;
+  const bStart = b.startedAt ?? 0;
+  if (aStart !== bStart) return aStart - bStart;
+  return a.runId.localeCompare(b.runId);
 }
-function inferEvidenceFileRole(relativePath) {
-  const normalized = assertEvidenceRelativePath(relativePath);
-  const base = normalized.includes("/") ? normalized.slice(normalized.lastIndexOf("/") + 1) : normalized;
-  if (base === "evidence.html" || base === "trace.html" || base.endsWith(".html")) {
-    return "report";
-  }
-  if (base === "trace.jsonl" || base.endsWith(".jsonl")) {
-    return "redacted-trace";
-  }
-  if (base === "check-results.json") {
-    return "checks";
-  }
-  if (base === "contract.resolved.json") {
-    return "contract";
-  }
-  if (base === "redaction-report.json") {
-    return "redaction-report";
-  }
-  if (base === "summary.md") {
-    return "summary";
+function buildGroups(runIds, metaByRunId) {
+  const byGroup = /* @__PURE__ */ new Map();
+  for (const runId of runIds) {
+    const groupId = metaByRunId.get(runId)?.groupId;
+    if (!groupId) continue;
+    const existing = byGroup.get(groupId);
+    if (existing) {
+      existing.runIds.push(runId);
+    } else {
+      byGroup.set(groupId, {
+        groupId,
+        parentGroupId: metaByRunId.get(runId)?.parentGroupId,
+        runIds: [runId]
+      });
+    }
   }
-  return "other";
+  return [...byGroup.values()].map((group) => ({
+    ...group,
+    runIds: [...group.runIds].sort((a, b) => a.localeCompare(b))
+  }));
 }
-function buildEvidenceFileEntries(files) {
-  const byPath = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const relativePath = assertEvidenceRelativePath(file.path);
-    if (relativePath === EVIDENCE_MANIFEST_FILENAME) {
-      throw new Error(
-        `Do not include ${EVIDENCE_MANIFEST_FILENAME} in packaged file hashes (self-hash is undefined).`
-      );
+function buildHandoffs(runIds, metaByRunId, warnings, sessionId) {
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushEdge = (edge) => {
+    const key = `${edge.from}->${edge.to}:${edge.confidence}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    edges.push(edge);
+  };
+  for (const runId of runIds) {
+    const meta = metaByRunId.get(runId);
+    if (!meta) continue;
+    if (meta.handoffFrom && meta.handoffTo) {
+      pushEdge({
+        from: meta.handoffFrom,
+        to: meta.handoffTo,
+        source: "manual",
+        confidence: "explicit"
+      });
+      continue;
     }
-    if (byPath.has(relativePath)) {
-      throw new Error(`Duplicate evidence file path: ${relativePath}`);
+    if (meta.handoffFrom) {
+      pushEdge({
+        from: meta.handoffFrom,
+        to: runId,
+        source: "manual",
+        confidence: "explicit"
+      });
+    }
+    if (meta.handoffTo) {
+      pushEdge({
+        from: runId,
+        to: meta.handoffTo,
+        source: "manual",
+        confidence: "explicit"
+      });
+    }
+    if (meta.subAgentId && meta.parentGroupId && !meta.handoffFrom && !meta.handoffTo) {
+      pushEdge({
+        from: meta.parentGroupId,
+        to: meta.subAgentId,
+        source: "inferred",
+        confidence: "correlated"
+      });
+      warnings.push({
+        code: "ambiguous-handoff-endpoints",
+        message: "Handoff inferred from parentGroupId and subAgentId without explicit handoffFrom/handoffTo.",
+        runId,
+        sessionId
+      });
     }
-    byPath.set(relativePath, {
-      path: relativePath,
-      sha256: sha256Hex(file.content),
-      role: file.role ?? inferEvidenceFileRole(relativePath)
-    });
   }
-  return [...byPath.values()].sort((a, b) => a.path.localeCompare(b.path));
+  return edges.sort((a, b) => {
+    const from = a.from.localeCompare(b.from);
+    if (from !== 0) return from;
+    return a.to.localeCompare(b.to);
+  });
 }
-function buildEvidenceManifest(parts) {
-  const runIds = [...parts.runIds];
-  if (runIds.length === 0) {
-    throw new Error("Evidence manifest requires at least one run id.");
-  }
-  for (const item of parts.sourceHashes) {
-    if (!runIds.includes(item.runId)) {
-      throw new Error(`sourceHashes runId "${item.runId}" is not listed in source.runIds.`);
+function buildRetries(runIds, metaByRunId, warnings, sessionId) {
+  const retries = [];
+  for (const runId of runIds) {
+    const meta = metaByRunId.get(runId);
+    if (!meta) continue;
+    if (meta.retryOf) {
+      retries.push({
+        runId,
+        retryOf: meta.retryOf,
+        attempt: meta.attempt,
+        source: "manual",
+        confidence: "explicit"
+      });
+      continue;
     }
-    if (item.algorithm !== "sha256") {
-      throw new Error(`Unsupported source hash algorithm: ${item.algorithm}`);
+    if (meta.attempt !== void 0 && meta.attempt > 1) {
+      retries.push({
+        runId,
+        attempt: meta.attempt,
+        source: "inferred",
+        confidence: "correlated"
+      });
+      warnings.push({
+        code: "ambiguous-retry-link",
+        message: "attempt > 1 without retryOf; retry link is correlated only.",
+        runId,
+        sessionId
+      });
     }
   }
-  const assessment = {
-    status: parts.assessmentStatus,
-    note: parts.note ?? EVIDENCE_ASSESSMENT_NOTE
+  return retries.sort((a, b) => a.runId.localeCompare(b.runId));
+}
+function buildCriticalPath(runs, handoffs) {
+  const runById = new Map(runs.map((run) => [run.runId, run]));
+  const explicitTargets = new Set(
+    handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.to)
+  );
+  const explicitSources = new Set(
+    handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.from)
+  );
+  const ordered = [...runs].sort(compareRuns);
+  const path14 = [];
+  const visited = /* @__PURE__ */ new Set();
+  const pushRun = (run, confidence, source) => {
+    if (visited.has(run.runId)) return;
+    visited.add(run.runId);
+    path14.push({
+      runId: run.runId,
+      name: run.name,
+      startedAt: run.startedAt,
+      durationMs: run.durationMs,
+      confidence,
+      source
+    });
   };
-  if (parts.sourceStatus !== void 0) {
-    assessment.sourceStatus = parts.sourceStatus;
+  for (const edge of handoffs) {
+    if (edge.confidence !== "explicit") continue;
+    const fromRun = [...runById.values()].find(
+      (run) => run.runId === edge.from || metaRunIdMatches(run, edge.from, runById)
+    );
+    const toRun = [...runById.values()].find(
+      (run) => run.runId === edge.to || metaRunIdMatches(run, edge.to, runById)
+    );
+    if (fromRun) pushRun(fromRun, "explicit", "manual");
+    if (toRun) pushRun(toRun, "explicit", "manual");
   }
-  return {
-    evidenceFormatVersion: EVIDENCE_FORMAT_VERSION,
-    generator: {
-      name: parts.generatorName ?? "agent-inspect",
-      version: parts.generatorVersion
-    },
-    createdAt: parts.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-    source: {
-      runIds,
-      traceSchemaVersions: [...parts.traceSchemaVersions].sort((a, b) => a.localeCompare(b)),
-      sourceHashes: [...parts.sourceHashes].sort((a, b) => a.runId.localeCompare(b.runId))
-    },
-    policy: {
-      redactionProfile: parts.redactionProfile,
-      verificationPolicy: parts.verificationPolicy ?? parts.redactionProfile
-    },
-    assessment,
-    ...parts.semantics !== void 0 ? { semantics: { ...parts.semantics } } : {},
-    ...parts.contract !== void 0 ? { contract: { ...parts.contract } } : {},
-    files: buildEvidenceFileEntries(parts.files)
-  };
-}
-function validateEvidenceManifest(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("Evidence manifest must be a JSON object.");
-  }
-  const record = value;
-  if (record.evidenceFormatVersion !== EVIDENCE_FORMAT_VERSION) {
-    throw new Error(
-      `Unsupported evidenceFormatVersion: ${String(record.evidenceFormatVersion)}`
-    );
-  }
-  const generator = record.generator;
-  if (generator === null || typeof generator !== "object" || Array.isArray(generator) || typeof generator.name !== "string" || typeof generator.version !== "string") {
-    throw new Error("Evidence manifest requires generator.name and generator.version.");
-  }
-  const source = record.source;
-  if (source === null || typeof source !== "object" || Array.isArray(source)) {
-    throw new Error("Evidence manifest requires source.");
-  }
-  const sourceRecord = source;
-  if (!Array.isArray(sourceRecord.runIds) || sourceRecord.runIds.length === 0) {
-    throw new Error("Evidence manifest source.runIds must be a non-empty array.");
-  }
-  if (!Array.isArray(sourceRecord.traceSchemaVersions)) {
-    throw new Error("Evidence manifest source.traceSchemaVersions must be an array.");
-  }
-  if (!Array.isArray(sourceRecord.sourceHashes)) {
-    throw new Error("Evidence manifest source.sourceHashes must be an array.");
-  }
-  const policy = record.policy;
-  if (policy === null || typeof policy !== "object" || Array.isArray(policy)) {
-    throw new Error("Evidence manifest requires policy.");
-  }
-  const assessment = record.assessment;
-  if (assessment === null || typeof assessment !== "object" || Array.isArray(assessment) || typeof assessment.status !== "string") {
-    throw new Error("Evidence manifest requires assessment.status.");
+  for (const run of ordered) {
+    if (visited.has(run.runId)) continue;
+    const confidence = explicitTargets.has(run.runId) || explicitSources.has(run.runId) ? "explicit" : "correlated";
+    pushRun(run, confidence, confidence === "explicit" ? "manual" : "inferred");
   }
-  if (!Array.isArray(record.files) || record.files.length === 0) {
-    throw new Error("Evidence manifest files must be a non-empty array.");
+  return path14;
+}
+function metaRunIdMatches(run, token, runById) {
+  const meta = extractSessionWorkflowMetadata(run.metadata);
+  return meta?.subAgentId === token || meta?.groupId === token || runById.has(token);
+}
+function buildSessionIndex(inputRuns, options = {}) {
+  const warnings = [];
+  const runs = [...inputRuns].sort(compareRuns);
+  const metaByRunId = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    metaByRunId.set(run.runId, extractSessionWorkflowMetadata(run.metadata));
   }
-  for (const file of record.files) {
-    if (file === null || typeof file !== "object" || Array.isArray(file)) {
-      throw new Error("Evidence manifest file entries must be objects.");
-    }
-    const entry = file;
-    if (typeof entry.path !== "string") {
-      throw new Error("Evidence file entry requires path.");
+  const sessionsByKey = /* @__PURE__ */ new Map();
+  const unscopedRunIds = [];
+  for (const run of runs) {
+    const meta = metaByRunId.get(run.runId);
+    const key = sessionKeyForRun(meta, {
+      correlateByGroupId: options.correlateByGroupId === true
+    });
+    if (!key) {
+      unscopedRunIds.push(run.runId);
+      continue;
     }
-    assertEvidenceRelativePath(entry.path);
-    if (typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/i.test(entry.sha256)) {
-      throw new Error(`Evidence file entry requires sha256 hex for ${entry.path}.`);
+    const bucket = sessionsByKey.get(key) ?? [];
+    bucket.push(run);
+    sessionsByKey.set(key, bucket);
+  }
+  const sessions = [...sessionsByKey.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([sessionId, sessionRuns]) => {
+    const runIds = sessionRuns.map((run) => run.runId).sort();
+    const handoffs = buildHandoffs(runIds, metaByRunId, warnings, sessionId);
+    const retries = buildRetries(runIds, metaByRunId, warnings, sessionId);
+    const groups = buildGroups(runIds, metaByRunId);
+    const criticalPath = buildCriticalPath(sessionRuns, handoffs);
+    const confidences = new Set(handoffs.map((edge) => edge.confidence));
+    if (confidences.has("explicit") && confidences.has("correlated")) {
+      warnings.push({
+        code: "mixed-confidence-group",
+        message: "Session aggregates explicit and correlated handoff edges.",
+        sessionId
+      });
     }
+    return enrichSessionSummary(
+      {
+        sessionId,
+        runIds,
+        groups,
+        handoffs,
+        retries,
+        criticalPath
+      },
+      runs,
+      {
+        nowMs: options.nowMs,
+        staleThresholdMs: options.staleThresholdMs
+      }
+    );
+  });
+  if (sessions.length === 0 && runs.length > 0) {
+    warnings.push({
+      code: "missing-session-id",
+      message: "No sessionId (or correlated groupId) found on input runs."
+    });
   }
-  return value;
+  warnings.sort((a, b) => {
+    const code = a.code.localeCompare(b.code);
+    if (code !== 0) return code;
+    return (a.runId ?? "").localeCompare(b.runId ?? "");
+  });
+  return {
+    runs,
+    sessions,
+    unscopedRunIds: unscopedRunIds.sort(),
+    warnings
+  };
 }
-function parseEvidenceManifestJson(text) {
-  let parsed;
+var KNOWN_EVENTS = /* @__PURE__ */ new Set([
+  "run_started",
+  "run_completed",
+  "step_started",
+  "step_completed"
+]);
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function safeParse(line) {
   try {
-    parsed = JSON.parse(text);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Evidence manifest is not valid JSON: ${message}`);
+    return JSON.parse(line);
+  } catch {
+    return void 0;
   }
-  return validateEvidenceManifest(parsed);
 }
-function collectTraceSchemaVersions(jsonl) {
-  const versions = /* @__PURE__ */ new Set();
-  for (const line of jsonl.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (trimmed === "") continue;
-    try {
-      const row = JSON.parse(trimmed);
-      if (typeof row.schemaVersion === "string" && row.schemaVersion.trim() !== "") {
-        versions.add(row.schemaVersion.trim());
+async function isAgentInspectTrace(filePath) {
+  try {
+    const rl = readline.createInterface({
+      input: fs.createReadStream(filePath, { encoding: "utf8" }),
+      crlfDelay: Infinity
+    });
+    let checked = 0;
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (trimmed === "") continue;
+      const parsed = safeParse(trimmed);
+      if (!parsed) continue;
+      if (!isRecord8(parsed)) continue;
+      checked += 1;
+      if (isTraceEvent(parsed)) return true;
+      const ev = parsed.event;
+      const runId = parsed.runId;
+      if (typeof ev === "string" && KNOWN_EVENTS.has(ev) && typeof runId === "string") {
+        return true;
       }
-    } catch {
+      if (checked >= 20) break;
     }
+    return false;
+  } catch {
+    return false;
   }
-  return [...versions].sort((a, b) => a.localeCompare(b));
 }
 
-// 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"]
+// packages/core/src/bundle/resolve.ts
+function parseSinceCutoff(since) {
+  const trimmed = since.trim();
+  if (trimmed === "") {
+    throw new Error("--since requires a non-empty duration (e.g. 24h, 7d).");
   }
-});
-function formatProgrammaticDiagnostic(code, detail) {
-  const spec = PROGRAMMATIC_DIAGNOSTIC_SPECS[code];
-  const summary = detail?.trim() ? detail.trim() : spec.summary;
-  return `${code}: ${summary} Remediation: ${spec.remediation}`;
-}
-
-// packages/core/src/checks/logical-events.ts
-function isRecord8(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;
+  return Date.now() - parseDuration(trimmed);
 }
-function stepIdOf(event) {
-  const value = event.attributes?.stepId;
-  if (typeof value === "string" && value.trim() !== "") return value;
+function runActivityMs(run) {
+  if (run.startedAt !== void 0 && Number.isFinite(run.startedAt)) return run.startedAt;
+  if (run.endedAt !== void 0 && Number.isFinite(run.endedAt)) return run.endedAt;
   return void 0;
 }
-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 mergeAttributes(start, complete) {
-  const merged = {
-    ...isRecord8(complete.attributes) ? complete.attributes : {},
-    ...isRecord8(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;
+function runsInSinceWindow(runs, since) {
+  const cutoff = parseSinceCutoff(since);
+  const ids = [];
+  for (const run of runs) {
+    const activity = runActivityMs(run);
+    if (activity !== void 0 && activity >= cutoff) {
+      ids.push(run.runId);
+    }
   }
-  return Object.keys(merged).length > 0 ? merged : void 0;
+  return ids.sort((a, b) => a.localeCompare(b));
 }
-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 {
-    ...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 } : {}
+function findSession(index, sessionId) {
+  return index.sessions.find((session) => session.sessionId === sessionId);
+}
+function resolveBundleRunIds(index, runs, options) {
+  const runId = options.runId?.trim();
+  const sessionId = options.sessionId?.trim();
+  const since = options.since?.trim();
+  const modes = [runId ? 1 : 0, sessionId ? 1 : 0, since ? 1 : 0].reduce((a, b) => a + b, 0);
+  if (modes === 0) {
+    throw new Error(
+      "bundle requires a run id, --session <sessionId>, or --since <duration>."
+    );
+  }
+  if (modes > 1) {
+    throw new Error(
+      "bundle accepts only one target: a run id, --session, or --since (not combined)."
+    );
+  }
+  if (runId) {
+    const known = runs.some((run) => run.runId === runId);
+    if (!known) {
+      throw new Error(`Run "${runId}" was not found in the trace directory.`);
+    }
+    return { runIds: [runId] };
+  }
+  if (sessionId) {
+    const session = findSession(index, sessionId);
+    if (!session) {
+      throw new Error(`Session "${sessionId}" was not found.`);
     }
+    if (session.runIds.length === 0) {
+      throw new Error(`Session "${sessionId}" has no runs to bundle.`);
+    }
+    return {
+      runIds: [...session.runIds].sort((a, b) => a.localeCompare(b)),
+      sessionId
+    };
+  }
+  const runIds = runsInSinceWindow(runs, since);
+  if (runIds.length === 0) {
+    throw new Error(`No runs matched --since ${since}.`);
+  }
+  return { runIds, since };
+}
+
+// packages/core/src/bundle/safety-status.ts
+function aggregateBundleSafeStatus(statuses) {
+  if (statuses.length === 0) return "UNKNOWN";
+  if (statuses.some((status) => status === "UNSAFE")) return "UNSAFE";
+  if (statuses.some((status) => status === "UNKNOWN")) return "UNKNOWN";
+  if (statuses.some((status) => status === "SAFE WITH WARNINGS")) return "SAFE WITH WARNINGS";
+  return "SAFE";
+}
+function toMetadataSafeStatus(status) {
+  if (status === "SAFE WITH WARNINGS") return "SAFE_WITH_WARNINGS";
+  return status;
+}
+function bundleFailsOnSafety(status, allowUnsafe) {
+  if (allowUnsafe) return false;
+  return status === "UNSAFE" || status === "UNKNOWN";
+}
+
+// packages/core/src/bundle/manifest.ts
+var BUNDLE_NOTE = "Generated locally by AgentInspect. Bundles are derived copies for review \u2014 not compliance or security certification. Review before sharing.";
+var PLACEHOLDER_NOTE = "No eval or performance artifacts were requested for this bundle.";
+function buildBundleMetadata(parts) {
+  const aggregate = aggregateBundleSafeStatus(
+    parts.checks.runs.map((run) => run.status)
+  );
+  return {
+    createdAt: parts.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    agentInspectVersion: parts.agentInspectVersion,
+    redactionProfile: parts.profile,
+    sourceTraceCount: parts.resolve.runIds.length,
+    runIds: [...parts.resolve.runIds],
+    safeStatus: toMetadataSafeStatus(aggregate),
+    files: [...parts.files].sort((a, b) => a.localeCompare(b)),
+    note: BUNDLE_NOTE,
+    ...parts.resolve.sessionId !== void 0 ? { sessionId: parts.resolve.sessionId } : {},
+    ...parts.resolve.since !== void 0 ? { since: parts.resolve.since } : {}
   };
 }
-function asLogical(event, extras) {
+function buildPlaceholderArtifact() {
   return {
-    ...cloneEvent(event),
-    sourceEventIds: Object.freeze([event.eventId]),
-    projection: {
-      paired: false,
-      absorbedEventIds: Object.freeze([]),
-      parentNormalized: extras?.parentNormalized === true,
-      ...{}
-    }
+    status: "not_requested",
+    note: PLACEHOLDER_NOTE
   };
 }
-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);
+
+// packages/core/src/bundle/summary.ts
+function markdownTable(rows) {
+  const lines = ["| Field | Value |", "| --- | --- |"];
+  for (const [key, value] of rows) {
+    lines.push(`| ${key} | ${value ?? "unknown"} |`);
   }
-  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);
-      }
-    }
-    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 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 lines.join("\n");
+}
+function buildBundleSummaryMarkdown(parts) {
+  const { metadata, checks, redaction } = parts;
+  const lines = [
+    "# AgentInspect trace bundle",
+    "",
+    metadata.note,
+    "",
+    "## Overview",
+    "",
+    markdownTable([
+      ["Created", metadata.createdAt],
+      ["AgentInspect", metadata.agentInspectVersion],
+      ["Redaction profile", metadata.redactionProfile],
+      ["Safe status", metadata.safeStatus],
+      ["Source traces", metadata.sourceTraceCount],
+      ["Runs", metadata.runIds.join(", ")],
+      ...metadata.sessionId ? [["Session", metadata.sessionId]] : [],
+      ...metadata.since ? [["Since", metadata.since]] : []
+    ]),
+    "",
+    "## Safety checks",
+    "",
+    `Aggregate: **${checks.aggregateStatus}**`,
+    ""
+  ];
+  for (const run of checks.runs) {
+    const source = run.sourceStatus !== void 0 && run.sourceStatus !== run.status ? `; source ${run.sourceStatus}` : "";
+    lines.push(
+      `- \`${run.runId}\`: artifact ${run.status}${source} (${run.findings} finding(s), ${run.errors} error(s), ${run.warnings} warning(s))`
+    );
   }
-  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;
-      }
+  lines.push("", "## Redaction", "", `Total findings: ${redaction.totalFindings}`, "");
+  for (const run of redaction.runs) {
+    const detectors = run.detectors.length > 0 ? run.detectors.join(", ") : "none";
+    lines.push(`- \`${run.runId}\`: ${run.findings} finding(s); detectors: ${detectors}`);
+  }
+  lines.push(
+    "",
+    "## Files",
+    "",
+    ...metadata.files.map((file) => `- \`${file}\``),
+    "",
+    "_Review every generated artifact before sharing outside your team._",
+    ""
+  );
+  return lines.join("\n");
+}
+function sanitizeBundleRunId(runId) {
+  let safe = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "run_unknown";
+  safe = path7__default.default.basename(safe);
+  safe = safe.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  if (safe === "" || safe === "." || safe === "..") {
+    safe = "run_unknown";
+  }
+  return safe;
+}
+function bundleRunAssetRelativePath(runId, extension) {
+  const safe = sanitizeBundleRunId(runId);
+  const ext = extension.startsWith(".") ? extension : `.${extension}`;
+  return path7__default.default.posix.join("assets", "runs", `${safe}${ext}`);
+}
+function assertBundlePathContained(outputDir, relativePath) {
+  const base = path7__default.default.resolve(outputDir);
+  const resolved = path7__default.default.resolve(base, relativePath);
+  if (resolved !== base && !resolved.startsWith(base + path7__default.default.sep)) {
+    throw new Error(`Bundle path escapes output directory: ${relativePath}`);
+  }
+  return resolved;
+}
+function normalizeBundleOutputPath(out, options) {
+  const trimmed = out.trim();
+  if (trimmed === "") {
+    throw new Error("--out requires a non-empty path.");
+  }
+  const resolved = path7__default.default.resolve(trimmed);
+  if (options?.preserveZipExtension !== true && resolved.toLowerCase().endsWith(".zip")) {
+    return resolved.slice(0, -4);
+  }
+  return resolved;
+}
+function defaultBundleOutputPath(runIds) {
+  const label = runIds.length === 1 ? sanitizeBundleRunId(runIds[0]) : `multi-${runIds.length}`;
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return path7__default.default.resolve(`agent-inspect-bundle-${label}-${stamp}`);
+}
+
+// packages/core/src/evidence/types.ts
+var EVIDENCE_FORMAT_VERSION = "1.0";
+var EVIDENCE_ASSESSMENT_NOTE = "Best-effort local safety verification only; not a compliance certification.";
+var EVIDENCE_MANIFEST_FILENAME = "evidence.json";
+var EVIDENCE_RESOLVED_CONTRACT_FILENAME = "contract.resolved.json";
+var SHA256_RE = /^[a-f0-9]{64}$/i;
+function sha256Hex(data) {
+  const hash = crypto.createHash("sha256");
+  if (typeof data === "string") {
+    hash.update(data, "utf8");
+  } else {
+    hash.update(data);
+  }
+  return hash.digest("hex");
+}
+function isSha256Hex(value) {
+  return SHA256_RE.test(value);
+}
+function sha256Equals(expected, actual) {
+  if (!isSha256Hex(expected) || !isSha256Hex(actual)) {
+    return false;
+  }
+  const a = expected.toLowerCase();
+  const b = actual.toLowerCase();
+  if (a.length !== b.length) return false;
+  let mismatch = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return mismatch === 0;
+}
+function assertEvidenceRelativePath(relativePath) {
+  if (typeof relativePath !== "string" || relativePath.trim() === "") {
+    throw new Error("Evidence file path must be a non-empty relative path.");
+  }
+  const trimmed = relativePath.trim().replaceAll("\\", "/");
+  if (path7__default.default.isAbsolute(trimmed) || trimmed.startsWith("/")) {
+    throw new Error(`Evidence file path must be relative: ${relativePath}`);
+  }
+  const parts = trimmed.split("/").filter((part) => part !== "");
+  if (parts.length === 0) {
+    throw new Error(`Evidence file path must be relative: ${relativePath}`);
+  }
+  for (const part of parts) {
+    if (part === "." || part === "..") {
+      throw new Error(`Evidence file path must not contain "." or "..": ${relativePath}`);
     }
-    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;
+  }
+  return parts.join("/");
+}
+
+// packages/core/src/evidence/manifest.ts
+function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (value === null || typeof value !== "object") return value;
+  const record = value;
+  return Object.fromEntries(
+    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable(record[key])])
+  );
+}
+function serializeEvidenceManifest(manifest) {
+  return `${JSON.stringify(stable(manifest), null, 2)}
+`;
+}
+function inferEvidenceFileRole(relativePath) {
+  const normalized = assertEvidenceRelativePath(relativePath);
+  const base = normalized.includes("/") ? normalized.slice(normalized.lastIndexOf("/") + 1) : normalized;
+  if (base === "evidence.html" || base === "trace.html" || base.endsWith(".html")) {
+    return "report";
+  }
+  if (base === "trace.jsonl" || base.endsWith(".jsonl")) {
+    return "redacted-trace";
+  }
+  if (base === "check-results.json") {
+    return "checks";
+  }
+  if (base === "contract.resolved.json") {
+    return "contract";
+  }
+  if (base === "redaction-report.json") {
+    return "redaction-report";
+  }
+  if (base === "summary.md") {
+    return "summary";
+  }
+  return "other";
+}
+function buildEvidenceFileEntries(files) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const relativePath = assertEvidenceRelativePath(file.path);
+    if (relativePath === EVIDENCE_MANIFEST_FILENAME) {
+      throw new Error(
+        `Do not include ${EVIDENCE_MANIFEST_FILENAME} in packaged file hashes (self-hash is undefined).`
+      );
     }
-    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;
+    if (byPath.has(relativePath)) {
+      throw new Error(`Duplicate evidence file path: ${relativePath}`);
     }
-    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
-      }
+    byPath.set(relativePath, {
+      path: relativePath,
+      sha256: sha256Hex(file.content),
+      role: file.role ?? inferEvidenceFileRole(relativePath)
     });
   }
-  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 [...byPath.values()].sort((a, b) => a.path.localeCompare(b.path));
+}
+function buildEvidenceManifest(parts) {
+  const runIds = [...parts.runIds];
+  if (runIds.length === 0) {
+    throw new Error("Evidence manifest requires at least one run id.");
+  }
+  for (const item of parts.sourceHashes) {
+    if (!runIds.includes(item.runId)) {
+      throw new Error(`sourceHashes runId "${item.runId}" is not listed in source.runIds.`);
+    }
+    if (item.algorithm !== "sha256") {
+      throw new Error(`Unsupported source hash algorithm: ${item.algorithm}`);
+    }
+  }
+  const assessment = {
+    status: parts.assessmentStatus,
+    note: parts.note ?? EVIDENCE_ASSESSMENT_NOTE
+  };
+  if (parts.sourceStatus !== void 0) {
+    assessment.sourceStatus = parts.sourceStatus;
+  }
   return {
-    logicalEvents: Object.freeze(normalized),
-    diagnostics: Object.freeze(diagnostics)
+    evidenceFormatVersion: EVIDENCE_FORMAT_VERSION,
+    generator: {
+      name: parts.generatorName ?? "agent-inspect",
+      version: parts.generatorVersion
+    },
+    createdAt: parts.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    source: {
+      runIds,
+      traceSchemaVersions: [...parts.traceSchemaVersions].sort((a, b) => a.localeCompare(b)),
+      sourceHashes: [...parts.sourceHashes].sort((a, b) => a.runId.localeCompare(b.runId))
+    },
+    policy: {
+      redactionProfile: parts.redactionProfile,
+      verificationPolicy: parts.verificationPolicy ?? parts.redactionProfile
+    },
+    assessment,
+    ...parts.semantics !== void 0 ? { semantics: { ...parts.semantics } } : {},
+    ...parts.contract !== void 0 ? { contract: { ...parts.contract } } : {},
+    ...parts.inputs !== void 0 ? { inputs: { ...parts.inputs } } : {},
+    files: buildEvidenceFileEntries(parts.files)
   };
 }
-function resolveCanonicalToolName(event) {
-  const attrs = event.attributes;
-  const direct = pickString(attrs, ["toolName", "tool"]);
-  if (direct) return direct;
-  const metadata = attrs?.metadata;
-  if (isRecord8(metadata)) {
-    const nested = pickString(metadata, ["toolName", "tool"]);
-    if (nested) return nested;
+function validateEvidenceManifest(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Evidence manifest must be a JSON object.");
   }
-  for (const prefix of ["tool:", "function:", "mcp-tools:"]) {
-    if (event.name.startsWith(prefix)) return event.name.slice(prefix.length);
+  const record = value;
+  if (record.evidenceFormatVersion !== EVIDENCE_FORMAT_VERSION) {
+    throw new Error(
+      `Unsupported evidenceFormatVersion: ${String(record.evidenceFormatVersion)}`
+    );
   }
-  return event.name;
+  const generator = record.generator;
+  if (generator === null || typeof generator !== "object" || Array.isArray(generator) || typeof generator.name !== "string" || typeof generator.version !== "string") {
+    throw new Error("Evidence manifest requires generator.name and generator.version.");
+  }
+  const source = record.source;
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    throw new Error("Evidence manifest requires source.");
+  }
+  const sourceRecord = source;
+  if (!Array.isArray(sourceRecord.runIds) || sourceRecord.runIds.length === 0) {
+    throw new Error("Evidence manifest source.runIds must be a non-empty array.");
+  }
+  if (!Array.isArray(sourceRecord.traceSchemaVersions)) {
+    throw new Error("Evidence manifest source.traceSchemaVersions must be an array.");
+  }
+  if (!Array.isArray(sourceRecord.sourceHashes)) {
+    throw new Error("Evidence manifest source.sourceHashes must be an array.");
+  }
+  const policy = record.policy;
+  if (policy === null || typeof policy !== "object" || Array.isArray(policy)) {
+    throw new Error("Evidence manifest requires policy.");
+  }
+  const assessment = record.assessment;
+  if (assessment === null || typeof assessment !== "object" || Array.isArray(assessment) || typeof assessment.status !== "string") {
+    throw new Error("Evidence manifest requires assessment.status.");
+  }
+  if (!Array.isArray(record.files) || record.files.length === 0) {
+    throw new Error("Evidence manifest files must be a non-empty array.");
+  }
+  for (const file of record.files) {
+    if (file === null || typeof file !== "object" || Array.isArray(file)) {
+      throw new Error("Evidence manifest file entries must be objects.");
+    }
+    const entry = file;
+    if (typeof entry.path !== "string") {
+      throw new Error("Evidence file entry requires path.");
+    }
+    assertEvidenceRelativePath(entry.path);
+    if (typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/i.test(entry.sha256)) {
+      throw new Error(`Evidence file entry requires sha256 hex for ${entry.path}.`);
+    }
+  }
+  return value;
 }
-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();
+function parseEvidenceManifestJson(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Evidence manifest is not valid JSON: ${message}`);
   }
-  return void 0;
+  return validateEvidenceManifest(parsed);
+}
+function collectTraceSchemaVersions(jsonl) {
+  const versions = /* @__PURE__ */ new Set();
+  for (const line of jsonl.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (typeof row.schemaVersion === "string" && row.schemaVersion.trim() !== "") {
+        versions.add(row.schemaVersion.trim());
+      }
+    } catch {
+    }
+  }
+  return [...versions].sort((a, b) => a.localeCompare(b));
 }
 
 // packages/core/src/checks/trace-facts.ts
@@ -6659,7 +6718,11 @@ function emptySummary2() {
     failed: 0,
     warnings: 0,
     errors: 0,
-    rulesEvaluated: 0
+    rulesEvaluated: 0,
+    rulesPassed: 0,
+    rulesWarning: 0,
+    rulesFailed: 0,
+    rulesError: 0
   };
 }
 function errorResult(input, diagnostics, selectedRun, ruleExecutions = []) {
@@ -6671,7 +6734,11 @@ function errorResult(input, diagnostics, selectedRun, ruleExecutions = []) {
     summary: {
       ...emptySummary2(),
       errors: diagnostics.filter((item) => item.severity === "error").length,
-      rulesEvaluated: ruleExecutions.length
+      rulesEvaluated: ruleExecutions.length,
+      rulesPassed: ruleExecutions.filter((item) => item.status === "pass").length,
+      rulesWarning: ruleExecutions.filter((item) => item.status === "warning").length,
+      rulesFailed: ruleExecutions.filter((item) => item.status === "fail").length,
+      rulesError: ruleExecutions.filter((item) => item.status === "error").length
     },
     findings: [],
     diagnostics: [...diagnostics],
@@ -6831,7 +6898,7 @@ function normalizeFinding(rule, finding) {
     ...finding.action !== void 0 ? { action: finding.action } : {}
   };
 }
-function summarize(findings, diagnostics, rulesEvaluated) {
+function summarize(findings, diagnostics, ruleExecutions) {
   return {
     passed: findings.filter((finding) => finding.status === "pass").length,
     failed: findings.filter(
@@ -6841,7 +6908,11 @@ function summarize(findings, diagnostics, rulesEvaluated) {
       (finding) => finding.status === "warning" || finding.severity === "warning"
     ).length,
     errors: diagnostics.filter((item) => item.severity === "error").length,
-    rulesEvaluated
+    rulesEvaluated: ruleExecutions.length,
+    rulesPassed: ruleExecutions.filter((item) => item.status === "pass").length,
+    rulesWarning: ruleExecutions.filter((item) => item.status === "warning").length,
+    rulesFailed: ruleExecutions.filter((item) => item.status === "fail").length,
+    rulesError: ruleExecutions.filter((item) => item.status === "error").length
   };
 }
 function classifyRuleExecution(findings, threw) {
@@ -7318,7 +7389,7 @@ function runTraceChecks(input, options = {}) {
   }
   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 summary = summarize(sortedFindings, diagnostics, ruleExecutions);
   const status = summary.failed > 0 ? "fail" : "pass";
   return {
     ok: status === "pass",
@@ -9395,6 +9466,28 @@ function asPositiveNumber(value, label) {
   }
   return value;
 }
+function asExpectConfig(value, label) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+  const raw = value;
+  const checkStatus = raw.checkStatus;
+  if (checkStatus !== "pass" && checkStatus !== "fail" && checkStatus !== "error") {
+    throw new Error(`${label}.checkStatus must be "pass", "fail", or "error".`);
+  }
+  const findingRuleIds = asStringArray(raw.findingRuleIds, `${label}.findingRuleIds`);
+  const minAssertions = asPositiveNumber(raw.minAssertions, `${label}.minAssertions`);
+  const rejectUnexpectedFindings = raw.rejectUnexpectedFindings === void 0 ? void 0 : typeof raw.rejectUnexpectedFindings === "boolean" ? raw.rejectUnexpectedFindings : (() => {
+    throw new Error(`${label}.rejectUnexpectedFindings must be a boolean.`);
+  })();
+  return {
+    checkStatus,
+    ...findingRuleIds !== void 0 ? { findingRuleIds } : {},
+    ...rejectUnexpectedFindings !== void 0 ? { rejectUnexpectedFindings } : {},
+    ...minAssertions !== void 0 ? { minAssertions } : {}
+  };
+}
 function validateCaseConfig(value, index) {
   const diagnostics = [];
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -9437,7 +9530,8 @@ function validateCaseConfig(value, index) {
             raw.expectedObservations,
             `cases[${index}].expectedObservations`
           )
-        } : {}
+        } : {},
+        ...asExpectConfig(raw.expect, `cases[${index}].expect`) !== void 0 ? { expect: asExpectConfig(raw.expect, `cases[${index}].expect`) } : {}
       },
       diagnostics
     };
@@ -12074,6 +12168,78 @@ function validateExpectedObservations(suiteCase, read) {
   }
   return { ok: diagnostics.length === 0, diagnostics };
 }
+function evaluateCaseExpect(suiteCase, checkResult, observationCount) {
+  const expectation = suiteCase.expect;
+  if (expectation === void 0) {
+    return { ok: true, diagnostics: [] };
+  }
+  const diagnostics = [];
+  if (checkResult.status !== expectation.checkStatus) {
+    diagnostics.push(
+      diagnostic4(
+        "AI_SUITE_EXPECT_MISMATCH",
+        `Expected check status "${expectation.checkStatus}", got "${checkResult.status}".`,
+        "error",
+        suiteCase.id
+      )
+    );
+  }
+  const failedFindings = checkResult.findings.filter(
+    (finding) => finding.status === "fail" && finding.severity === "error"
+  );
+  const requiredIds = expectation.findingRuleIds ?? [];
+  for (const ruleId of requiredIds) {
+    if (!failedFindings.some((finding) => finding.ruleId === ruleId)) {
+      diagnostics.push(
+        diagnostic4(
+          "AI_SUITE_EXPECT_MISMATCH",
+          `Expected failing finding for rule "${ruleId}" was not present.`,
+          "error",
+          suiteCase.id
+        )
+      );
+    }
+  }
+  const rejectUnexpected = expectation.rejectUnexpectedFindings !== false;
+  if (rejectUnexpected && requiredIds.length > 0) {
+    for (const finding of failedFindings) {
+      if (!requiredIds.includes(finding.ruleId)) {
+        diagnostics.push(
+          diagnostic4(
+            "AI_SUITE_EXPECT_MISMATCH",
+            `Unexpected failing finding for rule "${finding.ruleId}".`,
+            "error",
+            suiteCase.id
+          )
+        );
+      }
+    }
+  }
+  if (expectation.minAssertions !== void 0) {
+    const assertionCount = checkResult.ruleExecutions.length + observationCount;
+    if (assertionCount < expectation.minAssertions) {
+      diagnostics.push(
+        diagnostic4(
+          "AI_SUITE_EXPECT_MISMATCH",
+          `Expected at least ${expectation.minAssertions} assertion(s), got ${assertionCount}.`,
+          "error",
+          suiteCase.id
+        )
+      );
+    }
+  }
+  if (expectation.checkStatus === "fail" && checkResult.diagnostics.some((item) => item.severity === "error") && checkResult.status === "error") {
+    diagnostics.push(
+      diagnostic4(
+        "AI_SUITE_EXPECT_MISMATCH",
+        'Check ended in evaluator/config error; semantic failure expectation requires status "fail".',
+        "error",
+        suiteCase.id
+      )
+    );
+  }
+  return { ok: diagnostics.length === 0, diagnostics };
+}
 async function runSuiteCase(suiteCase, config, options) {
   const resolved = await resolveSuiteCaseTrace(suiteCase, options);
   if (resolved.missing || resolved.tracePath === void 0) {
@@ -12126,9 +12292,21 @@ async function runSuiteCase(suiteCase, config, options) {
     status: "pass",
     format: read.format,
     findings: [],
-    diagnostics: []};
+    diagnostics: [],
+    ruleExecutions: []
+  };
   const observationResult = validateExpectedObservations(suiteCase, read);
-  const diagnostics = [
+  const checkOk = checkResult.ok;
+  const observationsOk = observationResult.ok;
+  const evalOk = config.eval?.requireSuccess === true ? checkResult.findings.every(
+    (finding) => finding.ruleId !== "run.status" || finding.status !== "fail"
+  ) && checkResult.diagnostics.every((item) => item.severity !== "error") : void 0;
+  const expectResult = evaluateCaseExpect(
+    suiteCase,
+    checkResult,
+    compiled.observationCount
+  );
+  const checkFailureDiagnostics = [
     ...checkResult.diagnostics.map(
       (item) => diagnostic4(
         "AI_SUITE_CASE_CHECK_FAILED",
@@ -12144,15 +12322,24 @@ async function runSuiteCase(suiteCase, config, options) {
         finding.severity,
         suiteCase.id
       )
-    ),
-    ...observationResult.diagnostics
+    )
   ];
-  const checkOk = checkResult.ok;
-  const observationsOk = observationResult.ok;
-  const evalOk = config.eval?.requireSuccess === true ? checkResult.findings.every(
-    (finding) => finding.ruleId !== "run.status" || finding.status !== "fail"
-  ) && checkResult.diagnostics.every((item) => item.severity !== "error") : void 0;
-  const ok = checkOk && observationsOk;
+  const expectMatched = suiteCase.expect !== void 0 && expectResult.ok && observationsOk;
+  const diagnostics = expectMatched ? [
+    ...observationResult.diagnostics,
+    ...expectResult.diagnostics,
+    diagnostic4(
+      "AI_SUITE_CASE_CHECK_FAILED",
+      `Expected semantic failure matched (check.status=${checkResult.status}).`,
+      "info",
+      suiteCase.id
+    )
+  ] : [
+    ...checkFailureDiagnostics,
+    ...observationResult.diagnostics,
+    ...expectResult.diagnostics
+  ];
+  const ok = suiteCase.expect !== void 0 ? expectResult.ok && observationsOk : checkOk && observationsOk;
   const status = ok ? "pass" : checkResult.status === "error" ? "error" : "fail";
   return {
     id: suiteCase.id,
@@ -13345,6 +13532,18 @@ function renderGateReport(result, options = {}) {
 }
 
 // packages/core/src/inspect-run.ts
+var INSPECT_RUN_UNSUPPORTED_OPTION_KEYS = ["writer"];
+function warnUnsupportedInspectRunOptions(options) {
+  if (typeof options !== "object" || options === null || Array.isArray(options)) {
+    return;
+  }
+  const record = options;
+  for (const key of INSPECT_RUN_UNSUPPORTED_OPTION_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(record, key) && record[key] !== void 0) {
+      warn(formatProgrammaticDiagnostic("AI_INSPECT_RUN_UNSUPPORTED_OPTION"));
+    }
+  }
+}
 function normalizeRunName(name) {
   if (typeof name !== "string" || name.trim() === "") {
     return "unnamed-run";
@@ -13362,6 +13561,7 @@ async function inspectRun(name, fn, options) {
   if (typeof fn !== "function") {
     throw new TypeError("inspectRun requires `fn` to be a function");
   }
+  warnUnsupportedInspectRunOptions(options);
   if (options?.enabled === false) {
     return Promise.resolve(fn());
   }