@agent-inspect/mcp-server 4.4.0 → 5.1.0

package/dist/index.mjs

@@ -7,6 +7,7 @@ import os from 'os';
 import 'nanoid';
 import 'chalk';
 import 'fs';
+import 'url';
 
 // packages/mcp-server/src/index.ts
 
@@ -1524,7 +1525,7 @@ function summarize(findings, diagnostics) {
     errors: diagnostics.filter((item) => item.severity === "error").length
   };
 }
-function eventEvidence(event, path8) {
+function eventEvidence(event, path12) {
   return {
     runId: event.runId,
     eventId: event.eventId,
@@ -1635,1723 +1636,1745 @@ function runTraceChecks(input, options = {}) {
   };
 }
 
-// packages/core/src/diff/comparable.ts
-function extractOutputPreview(meta) {
-  if (meta === void 0) return void 0;
-  if ("outputPreview" in meta) return meta.outputPreview;
-  if ("resultPreview" in meta) return meta.resultPreview;
-  return void 0;
+// packages/core/src/persisted/token-usage.ts
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function mapStepStatus(s) {
-  if (s === void 0) return "running";
-  return s;
+function nonNegativeFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
 }
-function manualTraceEventsToComparableRun(events) {
-  const started = events.find((e) => e.event === "run_started");
-  if (!started || started.event !== "run_started") {
-    throw new Error("Invalid trace: missing run_started");
-  }
-  const rs = started;
-  const runId = rs.runId;
-  const completedAll = events.filter((e) => e.event === "run_completed");
-  const lastCompleted = completedAll[completedAll.length - 1];
-  let runStatus;
-  if (lastCompleted === void 0) runStatus = "running";
-  else runStatus = lastCompleted.status;
-  const durationMs = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
-  const steps = /* @__PURE__ */ new Map();
-  let order = 0;
-  for (const e of events) {
-    if (e.event !== "step_started") continue;
-    const s = e;
-    const meta = s.metadata ? { ...s.metadata } : void 0;
-    steps.set(s.stepId, {
-      id: s.stepId,
-      parentId: s.parentId,
-      name: s.name,
-      type: s.type,
-      order: order++,
-      timestamp: s.timestamp,
-      metadata: meta
-    });
-  }
-  for (const e of events) {
-    if (e.event !== "step_completed") continue;
-    const acc = steps.get(e.stepId);
-    if (!acc) continue;
-    acc.status = e.status;
-    acc.durationMs = e.durationMs;
-    if (e.error?.message) acc.errorMsg = e.error.message;
-    const extra = e;
-    if (extra.metadata !== void 0 && typeof extra.metadata === "object") {
-      acc.metadata = { ...acc.metadata ?? {}, ...extra.metadata };
-    }
-  }
-  const nodes = /* @__PURE__ */ new Map();
-  for (const acc of steps.values()) {
-    let meta = acc.metadata ? { ...acc.metadata } : void 0;
-    if (acc.parentId !== void 0 && !steps.has(acc.parentId)) {
-      meta = { ...meta ?? {}, agent_inspect_diff_parent_missing: true };
-    }
-    const outputPreview = extractOutputPreview(meta);
-    const sc = {
-      id: acc.id,
-      name: acc.name,
-      type: acc.type,
-      status: mapStepStatus(acc.status),
-      durationMs: acc.durationMs,
-      error: acc.errorMsg,
-      metadata: meta && Object.keys(meta).length > 0 ? meta : void 0,
-      outputPreview,
-      children: []
-    };
-    nodes.set(acc.id, sc);
-  }
-  const roots = [];
-  const sortByOrder = (a, b) => {
-    const oa = steps.get(a.id)?.order ?? 0;
-    const ob = steps.get(b.id)?.order ?? 0;
-    return oa - ob;
-  };
-  for (const acc of steps.values()) {
-    const node = nodes.get(acc.id);
-    if (acc.parentId !== void 0 && nodes.has(acc.parentId)) {
-      nodes.get(acc.parentId).children.push(node);
-    } else {
-      roots.push(node);
-    }
-  }
-  roots.sort(sortByOrder);
-  for (const n of nodes.values()) {
-    n.children.sort(sortByOrder);
+function normalizeTokenUsage(value) {
+  if (!isRecord5(value)) return void 0;
+  const input = nonNegativeFinite(value.input);
+  const output = nonNegativeFinite(value.output);
+  const suppliedTotal = nonNegativeFinite(value.total);
+  const cached = nonNegativeFinite(value.cached);
+  const derivedTotal = input !== void 0 && output !== void 0 && Number.isFinite(input + output) ? input + output : void 0;
+  const total = suppliedTotal ?? derivedTotal;
+  if (input === void 0 && output === void 0 && total === void 0 && cached === void 0) {
+    return void 0;
   }
   return {
-    runId,
-    name: rs.name,
-    status: runStatus,
-    durationMs,
-    steps: roots
+    ...input !== void 0 ? { input } : {},
+    ...output !== void 0 ? { output } : {},
+    ...total !== void 0 ? { total } : {},
+    ...cached !== void 0 ? { cached } : {}
   };
 }
 
-// packages/core/src/exporters/helpers.ts
-var REDACT_SUBSTRINGS = [
-  "authorization",
-  "cookie",
-  "token",
-  "apikey",
-  "password",
-  "secret",
-  "email"
-];
-function shouldRedactKey(key) {
-  const k = key.toLowerCase();
-  for (const s of REDACT_SUBSTRINGS) {
-    if (k.includes(s)) return true;
+// packages/core/src/persisted/from-trace-event.ts
+function sanitizeIdPart(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function nodeIdForEvent(event) {
+  switch (event.event) {
+    case "run_started":
+    case "run_completed":
+      return event.runId;
+    case "step_started":
+    case "step_completed":
+      return event.stepId;
+    case "outcome_observed":
+      return event.outcomeId;
+    default:
+      return "unknown";
   }
-  return false;
 }
-function safeString(value, maxLength) {
-  if (value === null || value === void 0) return "";
-  let s;
-  if (typeof value === "string") s = value;
-  else if (typeof value === "number" || typeof value === "boolean") s = String(value);
-  else s = stableJson(value, false);
-  if (maxLength !== void 0 && maxLength >= 0 && s.length > maxLength) {
-    return `${s.slice(0, maxLength)}\u2026`;
+function createPersistedEventId(event, eventIndex) {
+  const runId = sanitizeIdPart(event.runId);
+  const ev = sanitizeIdPart(event.event);
+  const node = sanitizeIdPart(nodeIdForEvent(event));
+  return `manual:${runId}:${ev}:${node}:${eventIndex}`;
+}
+function toIsoTimestamp(ms) {
+  if (typeof ms !== "number" || !Number.isFinite(ms)) {
+    return { iso: (/* @__PURE__ */ new Date(0)).toISOString(), invalidTimestamp: true };
   }
-  return s;
+  return { iso: new Date(ms).toISOString(), invalidTimestamp: false };
 }
-function escapeMarkdown(value) {
-  return value.replace(/\|/g, "\\|").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, " ");
+function buildSource(options) {
+  return {
+    type: "manual",
+    name: options?.sourceName ?? "trace-event",
+    version: options?.sourceVersion ?? "0.1"
+  };
 }
-function sortKeysDeep(input) {
-  if (input === null || typeof input !== "object") return input;
-  if (Array.isArray(input)) return input.map(sortKeysDeep);
-  const o = input;
-  const out = {};
-  for (const k of Object.keys(o).sort()) {
-    out[k] = sortKeysDeep(o[k]);
+function mapStepTypeToInspectKind(type) {
+  switch (type) {
+    case "run":
+      return "RUN";
+    case "llm":
+      return "LLM";
+    case "tool":
+      return "TOOL";
+    case "decision":
+      return "DECISION";
+    case "logic":
+    case "state":
+    case "custom":
+      return "LOGIC";
+    default:
+      return "LOGIC";
   }
-  return out;
 }
-function stableJson(value, pretty) {
-  const sorted = sortKeysDeep(value);
-  return pretty === true ? JSON.stringify(sorted, null, 2) : JSON.stringify(sorted);
+function mapRunOrStepStatus(status) {
+  return status === "success" ? "ok" : "error";
 }
-function compactAttributes(attrs, options) {
-  if (attrs === void 0) return {};
-  const maxLen = options?.maxLength ?? 500;
-  const out = {};
-  for (const key of Object.keys(attrs).sort()) {
-    if (shouldRedactKey(key)) {
-      out[key] = "[REDACTED]";
-      continue;
+function mapErrorInfo(error) {
+  if (!error?.message) {
+    return {};
+  }
+  const out = {
+    persisted: {
+      message: error.message,
+      name: "Error"
     }
-    const v = attrs[key];
-    out[key] = compactValue(v, maxLen);
+  };
+  if (typeof error.stack === "string" && error.stack.length > 0) {
+    out.errorStack = error.stack;
   }
   return out;
 }
-function compactValue(value, maxLen, redacted) {
-  if (value === null || typeof value !== "object") {
-    return typeof value === "string" ? safeString(value, maxLen) : value;
-  }
-  if (Array.isArray(value)) {
-    const arr = value.slice(0, 20).map((x) => compactValue(x, maxLen));
-    if (value.length > 20) arr.push(`\u2026(+${value.length - 20} more)`);
-    return arr;
-  }
-  const o = value;
-  const inner = {};
-  for (const k of Object.keys(o)) {
-    if (shouldRedactKey(k)) inner[k] = "[REDACTED]";
-    else inner[k] = compactValue(o[k], maxLen);
-  }
-  return inner;
+function mapTokenUsageFromMetadata(metadata) {
+  return normalizeTokenUsage(metadata?.tokens);
 }
-function flattenTree(tree) {
-  const out = [];
-  function walk(nodes) {
-    for (const n of nodes) {
-      out.push(n);
-      if (n.children.length > 0) walk(n.children);
+function compactAttributes(entries) {
+  const out = {};
+  for (const [key, value] of Object.entries(entries)) {
+    if (value !== void 0) {
+      out[key] = value;
     }
   }
-  walk(tree.children);
-  return out;
-}
-
-// packages/core/src/diff/engine.ts
-var DEFAULT_THRESHOLD_MS = 0;
-function pathSeg(step, index) {
-  return { index, name: step.name, stepId: step.id };
+  return Object.keys(out).length > 0 ? out : void 0;
 }
-function buildPath(segments) {
-  return { path: [...segments] };
-}
-function pairSteps(left, right) {
-  const usedRight = /* @__PURE__ */ new Set();
-  const pairs = [];
-  for (let i = 0; i < left.length; i++) {
-    const L = left[i];
-    let R = right.find((r) => !usedRight.has(r.id) && r.id === L.id);
-    if (R === void 0 && i < right.length && !usedRight.has(right[i].id)) {
-      const cand = right[i];
-      if (cand.name === L.name && (cand.type ?? "") === (L.type ?? "")) {
-        R = cand;
+function traceEventToPersistedInspectEvent(event, options) {
+  const eventIndex = options?.eventIndex ?? 0;
+  const eventId = createPersistedEventId(event, eventIndex);
+  const source = buildSource(options);
+  const tsMain = toIsoTimestamp(event.timestamp);
+  switch (event.event) {
+    case "run_started": {
+      const tsStart = toIsoTimestamp(event.startTime);
+      const correlation = extractCorrelationMetadata(event.metadata);
+      const attributes = compactAttributes({
+        legacyEvent: "run_started",
+        metadata: event.metadata !== void 0 ? { ...event.metadata } : void 0,
+        correlationId: correlation?.correlationId,
+        requestId: correlation?.requestId,
+        decisionId: correlation?.decisionId,
+        groupId: correlation?.groupId,
+        invalidTimestamp: tsMain.invalidTimestamp || tsStart.invalidTimestamp ? true : void 0
+      });
+      return {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: "RUN",
+        name: event.name,
+        status: "running",
+        timestamp: tsMain.iso,
+        startedAt: tsStart.iso,
+        confidence: "explicit",
+        source,
+        attributes
+      };
+    }
+    case "run_completed": {
+      const tsEnd = toIsoTimestamp(event.endTime);
+      const { persisted: error, errorStack } = mapErrorInfo(event.error);
+      const attributes = compactAttributes({
+        legacyEvent: "run_completed",
+        errorStack,
+        invalidTimestamp: tsMain.invalidTimestamp || tsEnd.invalidTimestamp ? true : void 0
+      });
+      return {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: "RUN",
+        name: "run",
+        status: mapRunOrStepStatus(event.status),
+        timestamp: tsMain.iso,
+        endedAt: tsEnd.iso,
+        durationMs: event.durationMs,
+        confidence: "explicit",
+        source,
+        attributes,
+        error
+      };
+    }
+    case "step_started": {
+      const tsStart = toIsoTimestamp(event.startTime);
+      const tokenUsage = mapTokenUsageFromMetadata(event.metadata);
+      const attributes = compactAttributes({
+        legacyEvent: "step_started",
+        stepId: event.stepId,
+        stepType: event.type,
+        metadata: event.metadata !== void 0 ? { ...event.metadata } : void 0,
+        invalidTimestamp: tsMain.invalidTimestamp || tsStart.invalidTimestamp ? true : void 0
+      });
+      const out = {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: mapStepTypeToInspectKind(event.type),
+        name: event.name,
+        status: "running",
+        timestamp: tsMain.iso,
+        startedAt: tsStart.iso,
+        confidence: "explicit",
+        source,
+        attributes
+      };
+      if (event.parentId !== void 0) {
+        out.parentId = event.parentId;
+      }
+      if (tokenUsage !== void 0) {
+        out.tokenUsage = tokenUsage;
       }
+      return out;
     }
-    if (R === void 0) {
-      R = right.find(
-        (r) => !usedRight.has(r.id) && r.name === L.name && (r.type ?? "") === (L.type ?? "")
-      );
+    case "step_completed": {
+      const tsEnd = toIsoTimestamp(event.endTime);
+      const { persisted: error, errorStack } = mapErrorInfo(event.error);
+      const attributes = compactAttributes({
+        legacyEvent: "step_completed",
+        stepId: event.stepId,
+        errorStack,
+        invalidTimestamp: tsMain.invalidTimestamp || tsEnd.invalidTimestamp ? true : void 0
+      });
+      return {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: "LOGIC",
+        name: event.stepId,
+        status: mapRunOrStepStatus(event.status),
+        timestamp: tsMain.iso,
+        endedAt: tsEnd.iso,
+        durationMs: event.durationMs,
+        confidence: "explicit",
+        source,
+        attributes,
+        error
+      };
     }
-    if (R !== void 0) {
-      usedRight.add(R.id);
-      pairs.push([L, R]);
-    } else {
-      pairs.push([L, void 0]);
+    case "outcome_observed": {
+      const tsObserved = toIsoTimestamp(event.observedAt);
+      const attributes = compactAttributes({
+        legacyEvent: "outcome_observed",
+        outcomeId: event.outcomeId,
+        outcomeStatus: event.status,
+        expectation: event.expectation,
+        method: event.method,
+        actual: event.actual,
+        evidence: event.evidence,
+        observedAt: tsObserved.iso,
+        invalidTimestamp: tsMain.invalidTimestamp || tsObserved.invalidTimestamp ? true : void 0
+      });
+      const out = {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: "OUTCOME",
+        name: event.name,
+        status: event.status === "failed" ? "error" : "ok",
+        timestamp: tsMain.iso,
+        confidence: "explicit",
+        source,
+        attributes
+      };
+      if (event.parentId !== void 0) {
+        out.parentId = event.parentId;
+      }
+      if (event.actual !== void 0) {
+        out.outputSummary = event.actual;
+      }
+      return out;
     }
-  }
-  for (const R of right) {
-    if (!usedRight.has(R.id)) {
-      pairs.push([void 0, R]);
+    default: {
+      const _exhaustive = event;
+      throw new Error(`Unsupported trace event: ${_exhaustive.event}`);
     }
   }
-  return pairs;
 }
-function compareLeafSteps(L, R, segments, opts, out) {
-  const path8 = buildPath(segments);
-  if (L.name !== R.name) {
-    out.push({
-      kind: "structure",
-      severity: "warning",
-      message: "Step name differs",
-      path: path8,
-      left: L.name,
-      right: R.name
-    });
-  }
-  if ((L.type ?? "") !== (R.type ?? "")) {
-    out.push({
-      kind: "step-type",
-      severity: "warning",
-      message: "Step type differs",
-      path: path8,
-      left: L.type,
-      right: R.type
-    });
-  }
-  if ((L.status ?? "") !== (R.status ?? "")) {
-    out.push({
-      kind: "step-status",
-      severity: "warning",
-      message: "Step status differs",
-      path: path8,
-      left: L.status,
-      right: R.status
-    });
+function traceEventsToPersistedInspectEvents(events, options) {
+  return events.map(
+    (event, index) => traceEventToPersistedInspectEvent(event, { ...options, eventIndex: index })
+  );
+}
+
+// packages/core/src/logs/tree-builder.ts
+function inc(map, key) {
+  map[key] = (map[key] ?? 0) + 1;
+}
+function computeRunStatus(events) {
+  let hasRunning = false;
+  for (const e of events) {
+    if (e.status === "error") return "error";
+    if (e.status === "running") hasRunning = true;
   }
-  const le = L.error ?? "";
-  const re = R.error ?? "";
-  if (le !== re) {
-    out.push({
-      kind: "error",
-      severity: "error",
-      message: "Step error message differs",
-      path: path8,
-      left: le || void 0,
-      right: re || void 0
-    });
+  if (hasRunning) return "running";
+  return "ok";
+}
+var TreeBuilder = class {
+  constructor(options) {
+    void options?.config;
   }
-  if (!opts.ignoreDuration) {
-    const ld = L.durationMs;
-    const rd = R.durationMs;
-    const th = opts.durationThresholdMs;
-    let differs = false;
-    if (ld === void 0 && rd === void 0) differs = false;
-    else if (ld === void 0 || rd === void 0) differs = true;
-    else differs = Math.abs(ld - rd) > th;
-    if (differs) {
-      out.push({
-        kind: "duration",
-        severity: "info",
-        message: "Step duration differs",
-        path: path8,
-        left: ld,
-        right: rd
-      });
+  build(events) {
+    const byRun = /* @__PURE__ */ new Map();
+    for (const e of events) {
+      if (!byRun.has(e.runId)) byRun.set(e.runId, []);
+      byRun.get(e.runId).push(e);
     }
-  }
-  const lm = stableJson(L.metadata ?? {});
-  const rm = stableJson(R.metadata ?? {});
-  if (lm !== rm) {
-    out.push({
-      kind: "metadata",
-      severity: "info",
-      message: "Step metadata differs",
-      path: path8,
-      left: L.metadata,
-      right: R.metadata
-    });
-  }
-  const lo = stableJson(L.outputPreview ?? null);
-  const ro = stableJson(R.outputPreview ?? null);
-  if (lo !== ro) {
-    out.push({
-      kind: "output",
-      severity: "info",
-      message: "Output preview differs",
-      path: path8,
-      left: L.outputPreview,
-      right: R.outputPreview
-    });
-  }
-}
-function compareRecursive(L, R, segments, opts, out) {
-  compareLeafSteps(L, R, segments, opts, out);
-  const pairs = pairSteps(L.children, R.children);
-  let ci = 0;
-  for (const [lch, rch] of pairs) {
-    if (lch !== void 0 && rch !== void 0) {
-      compareRecursive(lch, rch, [...segments, pathSeg(lch, ci)], opts, out);
-    } else if (lch !== void 0) {
-      out.push({
-        kind: "step-removed",
-        severity: "warning",
-        message: `Step only in left run: ${lch.name}`,
-        path: buildPath([...segments, pathSeg(lch, ci)]),
-        left: lch.id,
-        right: void 0
-      });
-    } else if (rch !== void 0) {
+    const out = [];
+    for (const [runId, runEvents] of byRun.entries()) {
+      const sorted = [...runEvents].sort((a, b) => a.timestamp - b.timestamp);
+      const nodes = /* @__PURE__ */ new Map();
+      for (const e of sorted) {
+        nodes.set(e.eventId, { event: e, children: [], depth: 0 });
+      }
+      const roots = [];
+      for (const node of nodes.values()) {
+        const parentId = node.event.parentId;
+        if (parentId && nodes.has(parentId)) {
+          nodes.get(parentId).children.push(node);
+        } else {
+          roots.push(node);
+        }
+      }
+      const assignDepth = (n, depth) => {
+        n.depth = depth;
+        for (const c of n.children) assignDepth(c, depth + 1);
+      };
+      for (const r of roots) assignDepth(r, 0);
+      const confidenceBreakdown = {
+        explicit: 0,
+        correlated: 0,
+        heuristic: 0,
+        unknown: 0
+      };
+      const kinds = {};
+      for (const e of sorted) {
+        inc(confidenceBreakdown, e.confidence);
+        kinds[e.kind] = (kinds[e.kind] ?? 0) + 1;
+      }
+      const startedAt = sorted.length > 0 ? sorted[0].timestamp : void 0;
+      const endedAt = sorted.length > 0 ? sorted[sorted.length - 1].timestamp : void 0;
+      const status = computeRunStatus(sorted);
+      const durationMs = startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt && status !== "running" ? endedAt - startedAt : void 0;
+      const name = sorted.find((e) => e.kind === "RUN")?.name;
       out.push({
-        kind: "step-added",
-        severity: "warning",
-        message: `Step only in right run: ${rch.name}`,
-        path: buildPath([...segments, pathSeg(rch, ci)]),
-        left: void 0,
-        right: rch.id
+        runId,
+        name,
+        status,
+        startedAt,
+        endedAt: status === "running" ? void 0 : endedAt,
+        durationMs,
+        children: roots,
+        metadata: {
+          totalEvents: sorted.length,
+          confidenceBreakdown,
+          kinds
+        }
       });
     }
-    ci += 1;
+    out.sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0));
+    return out;
+  }
+};
+
+// packages/core/src/persisted/to-inspect-event.ts
+function compactAttributes2(entries) {
+  const out = {};
+  for (const [key, value] of Object.entries(entries)) {
+    if (value !== void 0) {
+      out[key] = value;
+    }
   }
+  return Object.keys(out).length > 0 ? out : void 0;
 }
-function mergeDiffDefaults(options) {
+function parseIsoToMs3(iso) {
+  const parsed = Date.parse(iso);
+  if (!Number.isFinite(parsed)) {
+    return { ms: 0, invalidTimestamp: true };
+  }
+  return { ms: parsed, invalidTimestamp: false };
+}
+function mapPersistedSourceToInspect(event) {
+  const attrs = event.attributes ?? {};
+  const sourceName = event.source.name;
+  if (sourceName === "pino") {
+    return {
+      type: "pino",
+      file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
+      line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
+    };
+  }
+  if (sourceName === "winston") {
+    return {
+      type: "winston",
+      file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
+      line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
+    };
+  }
+  const mapType = (t) => {
+    switch (t) {
+      case "manual":
+        return "manual";
+      case "json-log":
+        return "json-log";
+      case "log4js":
+        return "log4js";
+      case "adapter":
+      case "ai-sdk":
+      case "otel":
+        return "adapter";
+      default:
+        return "json-log";
+    }
+  };
   return {
-    ignoreDuration: false,
-    durationThresholdMs: DEFAULT_THRESHOLD_MS,
-    focus: "all",
-    check: "all"
+    type: mapType(event.source.type),
+    file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
+    line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
   };
 }
-function kindMatchesFilter(kind, merged) {
-  return true;
-}
-function diffRuns(left, right, options) {
-  const merged = mergeDiffDefaults();
-  const opts = {
-    ignoreDuration: merged.ignoreDuration,
-    durationThresholdMs: merged.durationThresholdMs
-  };
-  const raw = [];
-  if ((left.status ?? "") !== (right.status ?? "")) {
-    raw.push({
-      kind: "run-status",
-      severity: "warning",
-      message: "Run completion status differs",
-      left: left.status,
-      right: right.status
-    });
+function buildInspectAttributes(event) {
+  const attrs = event.attributes !== void 0 ? { ...event.attributes } : {};
+  if (event.inputSummary !== void 0) {
+    attrs.inputSummary = event.inputSummary;
   }
-  {
-    const ld = left.durationMs;
-    const rd = right.durationMs;
-    const th = merged.durationThresholdMs;
-    let differs = false;
-    if (ld === void 0 && rd === void 0) differs = false;
-    else if (ld === void 0 || rd === void 0) differs = true;
-    else differs = Math.abs(ld - rd) > th;
-    if (differs) {
-      raw.push({
-        kind: "duration",
-        severity: "info",
-        message: "Run duration differs",
-        left: ld,
-        right: rd
-      });
-    }
+  if (event.outputSummary !== void 0) {
+    attrs.outputSummary = event.outputSummary;
   }
-  const pairs = pairSteps(left.steps, right.steps);
-  let idx = 0;
-  for (const [ls, rs] of pairs) {
-    if (ls !== void 0 && rs !== void 0) {
-      compareRecursive(ls, rs, [pathSeg(ls, idx)], opts, raw);
-      idx += 1;
-    } else if (ls !== void 0) {
-      raw.push({
-        kind: "step-removed",
-        severity: "warning",
-        message: `Step only in left run: ${ls.name}`,
-        path: buildPath([pathSeg(ls, idx)]),
-        left: ls.id,
-        right: void 0
-      });
-      idx += 1;
-    } else if (rs !== void 0) {
-      raw.push({
-        kind: "step-added",
-        severity: "warning",
-        message: `Step only in right run: ${rs.name}`,
-        path: buildPath([pathSeg(rs, idx)]),
-        left: void 0,
-        right: rs.id
-      });
-      idx += 1;
+  if (event.error) {
+    if (event.error.name !== void 0) {
+      attrs.errorName = event.error.name;
+    }
+    attrs.errorMessage = event.error.message;
+    if (event.error.code !== void 0) {
+      attrs.errorCode = event.error.code;
     }
   }
-  const differences = raw.filter((d) => kindMatchesFilter(d.kind));
-  let errors = 0;
-  let warnings = 0;
-  let info = 0;
-  for (const d of differences) {
-    if (d.severity === "error") errors += 1;
-    else if (d.severity === "warning") warnings += 1;
-    else info += 1;
+  if (event.tokenUsage) {
+    attrs.tokens = { ...event.tokenUsage };
   }
-  const firstVisible = differences[0];
-  const firstDivergence = firstVisible !== void 0 ? {
-    kind: "first-divergence",
-    severity: firstVisible.severity,
-    message: `First divergence: ${firstVisible.message}`,
-    path: firstVisible.path,
-    left: firstVisible.left,
-    right: firstVisible.right
-  } : void 0;
-  const summary = {
-    leftRunId: left.runId,
-    rightRunId: right.runId,
-    totalDifferences: differences.length,
-    errors,
-    warnings,
-    info,
-    firstDivergence
-  };
-  return { summary, differences };
-}
-
-// packages/core/src/exporters/markdown-exporter.ts
-function renderTreeAscii(nodes, indent = "") {
-  const lines = [];
-  for (let i = 0; i < nodes.length; i++) {
-    const n = nodes[i];
-    const last = i === nodes.length - 1;
-    const branch = last ? "\u2514\u2500 " : "\u251C\u2500 ";
-    const ev = n.event;
-    const status = ev.status ?? "?";
-    const dur = ev.durationMs !== void 0 && Number.isFinite(ev.durationMs) ? `${ev.durationMs}ms` : "-";
-    lines.push(`${indent}${branch}${escapeMarkdown(ev.name)} [${ev.kind}] ${status} (${dur})`);
-    const nextIndent = indent + (last ? "   " : "\u2502  ");
-    if (n.children.length > 0) {
-      const childStr = renderTreeAscii(n.children, nextIndent);
-      if (childStr.length > 0) lines.push(childStr);
-    }
-  }
-  return lines.join("\n");
-}
-function exportMarkdown(tree, options) {
-  const warnings = [];
-  const includeMetadata = options?.includeMetadata ?? true;
-  const includeAttributes = options?.includeAttributes ?? false;
-  const includeErrors = options?.includeErrors ?? true;
-  const maxLen = options?.maxAttributeLength ?? 500;
-  const titleName = tree.name ?? tree.runId;
-  const lines = [];
-  lines.push(`# AgentInspect Run: ${escapeMarkdown(titleName)}`);
-  lines.push("");
-  lines.push("Generated locally by AgentInspect. Review for sensitive data before sharing.");
-  lines.push("");
-  if (includeMetadata) {
-    lines.push("## Summary");
-    lines.push("");
-    lines.push(`- **runId**: ${escapeMarkdown(tree.runId)}`);
-    if (tree.name !== void 0) lines.push(`- **name**: ${escapeMarkdown(tree.name)}`);
-    lines.push(`- **status**: ${escapeMarkdown(String(tree.status ?? "unknown"))}`);
-    lines.push(
-      `- **durationMs**: ${tree.durationMs !== void 0 ? escapeMarkdown(String(tree.durationMs)) : "-"}`
-    );
-    lines.push(
-      `- **startedAt**: ${tree.startedAt !== void 0 ? escapeMarkdown(String(tree.startedAt)) : "-"}`
-    );
-    lines.push(
-      `- **endedAt**: ${tree.endedAt !== void 0 ? escapeMarkdown(String(tree.endedAt)) : "-"}`
-    );
-    lines.push(`- **totalEvents**: ${tree.metadata.totalEvents}`);
-    lines.push("");
-    lines.push("### Confidence breakdown");
-    lines.push("");
-    lines.push("| bucket | count |");
-    lines.push("| --- | --- |");
-    for (const k of Object.keys(tree.metadata.confidenceBreakdown).sort()) {
-      const key = k;
-      lines.push(
-        `| ${escapeMarkdown(key)} | ${tree.metadata.confidenceBreakdown[key]} |`
-      );
-    }
-    lines.push("");
-    lines.push("### Kind breakdown");
-    lines.push("");
-    lines.push("| kind | count |");
-    lines.push("| --- | --- |");
-    for (const k of Object.keys(tree.metadata.kinds).sort()) {
-      const key = k;
-      const c = tree.metadata.kinds[key];
-      if (c > 0) lines.push(`| ${escapeMarkdown(key)} | ${c} |`);
-    }
-    lines.push("");
+  if (event.source.type === "ai-sdk" || event.source.type === "otel") {
+    attrs.originalSourceType = event.source.type;
   }
-  lines.push("## Execution tree");
-  lines.push("");
-  lines.push("```text");
-  lines.push(
-    tree.children.length > 0 ? renderTreeAscii(tree.children) : "(no steps)"
-  );
-  lines.push("```");
-  lines.push("");
-  const flat = flattenTree(tree);
-  const errors = flat.filter((n) => n.event.status === "error");
-  if (includeErrors && errors.length > 0) {
-    lines.push("## Errors");
-    lines.push("");
-    for (const n of errors) {
-      const msg = n.event.attributes && typeof n.event.attributes.error === "object" ? safeString(
-        n.event.attributes.error.message,
-        maxLen
-      ) : "";
-      lines.push(
-        `- **${escapeMarkdown(n.event.name)}** (${escapeMarkdown(n.event.eventId)}): ${escapeMarkdown(msg || "error")}`
-      );
-    }
-    lines.push("");
+  if (event.source.name !== void 0) {
+    attrs.sourceName = event.source.name;
   }
-  if (includeAttributes) {
-    lines.push("## Attributes (bounded)");
-    lines.push("");
-    for (const n of flat) {
-      if (!n.event.attributes || Object.keys(n.event.attributes).length === 0) continue;
-      const compact = compactAttributes(n.event.attributes, {
-        maxLength: maxLen});
-      lines.push(`### ${escapeMarkdown(n.event.name)}`);
-      lines.push("");
-      lines.push("```json");
-      lines.push(stableJson(compact, true));
-      lines.push("```");
-      lines.push("");
-    }
-    warnings.push(
-      "Attributes may still contain sensitive data; review exports before sharing."
-    );
+  if (event.source.version !== void 0) {
+    attrs.sourceVersion = event.source.version;
   }
-  return {
-    format: "markdown",
-    content: lines.join("\n"),
-    contentType: "text/markdown",
-    fileExtension: ".md",
-    warnings
-  };
-}
-
-// packages/core/src/persisted/token-usage.ts
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function nonNegativeFinite(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+  return attrs;
 }
-function normalizeTokenUsage(value) {
-  if (!isRecord5(value)) return void 0;
-  const input = nonNegativeFinite(value.input);
-  const output = nonNegativeFinite(value.output);
-  const suppliedTotal = nonNegativeFinite(value.total);
-  const cached = nonNegativeFinite(value.cached);
-  const derivedTotal = input !== void 0 && output !== void 0 && Number.isFinite(input + output) ? input + output : void 0;
-  const total = suppliedTotal ?? derivedTotal;
-  if (input === void 0 && output === void 0 && total === void 0 && cached === void 0) {
-    return void 0;
+function persistedInspectEventToInspectEvent(event) {
+  if (!isPersistedInspectEvent(event)) {
+    throw new Error("Invalid PersistedInspectEvent: failed isPersistedInspectEvent");
   }
-  return {
-    ...input !== void 0 ? { input } : {},
-    ...output !== void 0 ? { output } : {},
-    ...total !== void 0 ? { total } : {},
-    ...cached !== void 0 ? { cached } : {}
-  };
-}
-
-// packages/core/src/persisted/from-trace-event.ts
-function sanitizeIdPart(value) {
-  return value.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-function nodeIdForEvent(event) {
-  switch (event.event) {
-    case "run_started":
-    case "run_completed":
-      return event.runId;
-    case "step_started":
-    case "step_completed":
-      return event.stepId;
-    case "outcome_observed":
-      return event.outcomeId;
-    default:
-      return "unknown";
+  const ts = parseIsoToMs3(event.timestamp);
+  const attrs = buildInspectAttributes(event);
+  if (ts.invalidTimestamp) {
+    attrs.invalidTimestamp = true;
   }
-}
-function createPersistedEventId(event, eventIndex) {
-  const runId = sanitizeIdPart(event.runId);
-  const ev = sanitizeIdPart(event.event);
-  const node = sanitizeIdPart(nodeIdForEvent(event));
-  return `manual:${runId}:${ev}:${node}:${eventIndex}`;
-}
-function toIsoTimestamp(ms) {
-  if (typeof ms !== "number" || !Number.isFinite(ms)) {
-    return { iso: (/* @__PURE__ */ new Date(0)).toISOString(), invalidTimestamp: true };
+  let status;
+  if (event.status === "running" || event.status === "ok" || event.status === "error") {
+    status = event.status;
+  } else if (event.status === "unknown") {
+    attrs.persistedStatus = "unknown";
   }
-  return { iso: new Date(ms).toISOString(), invalidTimestamp: false };
-}
-function buildSource(options) {
-  return {
-    type: "manual",
-    name: options?.sourceName ?? "trace-event",
-    version: options?.sourceVersion ?? "0.1"
+  const out = {
+    eventId: event.eventId,
+    runId: event.runId,
+    name: event.name,
+    kind: event.kind,
+    timestamp: ts.ms,
+    confidence: event.confidence,
+    source: mapPersistedSourceToInspect(event),
+    attributes: compactAttributes2(attrs)
   };
-}
-function mapStepTypeToInspectKind(type) {
-  switch (type) {
-    case "run":
-      return "RUN";
-    case "llm":
-      return "LLM";
-    case "tool":
-      return "TOOL";
-    case "decision":
-      return "DECISION";
-    case "logic":
-    case "state":
-    case "custom":
-      return "LOGIC";
-    default:
-      return "LOGIC";
+  if (event.parentId !== void 0) {
+    out.parentId = event.parentId;
   }
-}
-function mapRunOrStepStatus(status) {
-  return status === "success" ? "ok" : "error";
-}
-function mapErrorInfo(error) {
-  if (!error?.message) {
-    return {};
+  if (status !== void 0) {
+    out.status = status;
   }
-  const out = {
-    persisted: {
-      message: error.message,
-      name: "Error"
-    }
-  };
-  if (typeof error.stack === "string" && error.stack.length > 0) {
-    out.errorStack = error.stack;
+  if (event.durationMs !== void 0 && Number.isFinite(event.durationMs) && event.durationMs >= 0) {
+    out.durationMs = event.durationMs;
   }
   return out;
 }
-function mapTokenUsageFromMetadata(metadata) {
-  return normalizeTokenUsage(metadata?.tokens);
-}
-function compactAttributes2(entries) {
-  const out = {};
-  for (const [key, value] of Object.entries(entries)) {
-    if (value !== void 0) {
-      out[key] = value;
+function persistedInspectEventsToInspectEvents(events, options) {
+  const skipInvalid = options?.skipInvalid === true;
+  const out = [];
+  for (const event of events) {
+    if (!isPersistedInspectEvent(event)) {
+      if (skipInvalid) {
+        continue;
+      }
+      throw new Error("Invalid PersistedInspectEvent: failed isPersistedInspectEvent");
     }
+    out.push(persistedInspectEventToInspectEvent(event));
   }
-  return Object.keys(out).length > 0 ? out : void 0;
+  return out;
 }
-function traceEventToPersistedInspectEvent(event, options) {
-  const eventIndex = options?.eventIndex ?? 0;
-  const eventId = createPersistedEventId(event, eventIndex);
-  const source = buildSource(options);
-  const tsMain = toIsoTimestamp(event.timestamp);
-  switch (event.event) {
-    case "run_started": {
-      const tsStart = toIsoTimestamp(event.startTime);
-      const correlation = extractCorrelationMetadata(event.metadata);
-      const attributes = compactAttributes2({
-        legacyEvent: "run_started",
-        metadata: event.metadata !== void 0 ? { ...event.metadata } : void 0,
-        correlationId: correlation?.correlationId,
-        requestId: correlation?.requestId,
-        decisionId: correlation?.decisionId,
-        groupId: correlation?.groupId,
-        invalidTimestamp: tsMain.invalidTimestamp || tsStart.invalidTimestamp ? true : void 0
-      });
-      return {
-        schemaVersion: "0.2",
-        eventId,
-        runId: event.runId,
-        kind: "RUN",
-        name: event.name,
-        status: "running",
-        timestamp: tsMain.iso,
-        startedAt: tsStart.iso,
-        confidence: "explicit",
-        source,
-        attributes
-      };
+
+// packages/core/src/persisted/tree-bridge.ts
+function persistedInspectEventsToRunTrees(events, options) {
+  const inspectEvents = persistedInspectEventsToInspectEvents(events, {
+    skipInvalid: options?.skipInvalid
+  });
+  return new TreeBuilder().build(inspectEvents);
+}
+
+// packages/core/src/readers/index.ts
+var DEFAULT_MAX_TRACE_INPUT_BYTES = 10 * 1024 * 1024;
+var MIN_DETECTION_CONFIDENCE = 0.5;
+var AMBIGUOUS_CONFIDENCE_DELTA = 0.05;
+var resolvedInputCache = /* @__PURE__ */ new WeakMap();
+var OPENINFERENCE_READER_FORMAT = "openinference-json";
+var OTLP_READER_FORMAT = "otlp-json";
+var OPENINFERENCE_SPAN_KEYS = /* @__PURE__ */ new Set([
+  "trace_id",
+  "traceId",
+  "span_id",
+  "spanId",
+  "parent_span_id",
+  "parentSpanId",
+  "name",
+  "start_time_unix_nano",
+  "startTimeUnixNano",
+  "end_time_unix_nano",
+  "endTimeUnixNano",
+  "start_time",
+  "startTime",
+  "end_time",
+  "endTime",
+  "attributes",
+  "status",
+  "kind",
+  "span_kind",
+  "spanKind"
+]);
+var OPENINFERENCE_SENSITIVE_ATTRIBUTE_KEYS = [
+  "input.value",
+  "output.value",
+  "input.mime_type",
+  "output.mime_type",
+  "llm.input_messages",
+  "llm.output_messages",
+  "llm.prompts",
+  "llm.completions",
+  "retrieval.documents",
+  "reranker.input_documents",
+  "reranker.output_documents",
+  "document.content",
+  "gen_ai.prompt",
+  "gen_ai.completion",
+  "gen_ai.input.messages",
+  "gen_ai.output.messages"
+];
+var OTLP_SPAN_KEYS = /* @__PURE__ */ new Set([
+  "traceId",
+  "spanId",
+  "parentSpanId",
+  "name",
+  "kind",
+  "startTimeUnixNano",
+  "endTimeUnixNano",
+  "attributes",
+  "events",
+  "status",
+  "droppedAttributesCount",
+  "droppedEventsCount",
+  "droppedLinksCount",
+  "links",
+  "flags"
+]);
+var TraceReadError = class extends Error {
+  code;
+  warnings;
+  constructor(code, message, warnings = []) {
+    super(message);
+    this.name = "TraceReadError";
+    this.code = code;
+    this.warnings = warnings;
+  }
+};
+function normalizeCandidate(reader, candidate) {
+  const confidence = Number.isFinite(candidate.confidence) ? Math.max(0, Math.min(1, candidate.confidence)) : 0;
+  return {
+    ...candidate,
+    format: candidate.format || reader.format,
+    confidence,
+    readerName: candidate.readerName ?? reader.name
+  };
+}
+function sortCandidates(candidates) {
+  return [...candidates].sort((a, b) => {
+    if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+    return a.format.localeCompare(b.format);
+  });
+}
+function collectWarnings(candidates) {
+  return candidates.flatMap((candidate) => candidate.warnings ?? []);
+}
+function dedupeWarnings(warnings) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const warning of warnings) {
+    const key = [
+      warning.code,
+      warning.message,
+      warning.severity ?? "",
+      warning.sourceFile ?? "",
+      warning.line ?? "",
+      warning.field ?? ""
+    ].join("\0");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(warning);
+  }
+  return out;
+}
+function attachSingleSourceFile(warnings, resolved) {
+  if (resolved.sourceFiles.length !== 1) return [...warnings];
+  const [sourceFile] = resolved.sourceFiles;
+  return warnings.map((warning) => ({
+    ...warning,
+    sourceFile: warning.sourceFile ?? sourceFile
+  }));
+}
+function findReaderByFormat(format, readers) {
+  return readers.find((reader) => reader.format === format);
+}
+async function jsonlFilesInDirectory(dirPath) {
+  const entries = await readdir(dirPath, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
+}
+async function resolveInput(input) {
+  const cached = resolvedInputCache.get(input);
+  if (cached) return cached;
+  const promise = resolveInputUncached(input);
+  resolvedInputCache.set(input, promise);
+  return promise;
+}
+function assertInputWithinBounds(content, sourceFile) {
+  const bytes = Buffer.byteLength(content, "utf8");
+  if (bytes <= DEFAULT_MAX_TRACE_INPUT_BYTES) return;
+  throw new TraceReadError("unsupported_format", "Trace input exceeds the local reader size limit.", [
+    {
+      code: "input_too_large",
+      message: `Trace input is ${bytes} bytes; max is ${DEFAULT_MAX_TRACE_INPUT_BYTES} bytes.`,
+      severity: "error",
+      ...sourceFile !== void 0 ? { sourceFile } : {}
     }
-    case "run_completed": {
-      const tsEnd = toIsoTimestamp(event.endTime);
-      const { persisted: error, errorStack } = mapErrorInfo(event.error);
-      const attributes = compactAttributes2({
-        legacyEvent: "run_completed",
-        errorStack,
-        invalidTimestamp: tsMain.invalidTimestamp || tsEnd.invalidTimestamp ? true : void 0
-      });
-      return {
-        schemaVersion: "0.2",
-        eventId,
-        runId: event.runId,
-        kind: "RUN",
-        name: "run",
-        status: mapRunOrStepStatus(event.status),
-        timestamp: tsMain.iso,
-        endedAt: tsEnd.iso,
-        durationMs: event.durationMs,
-        confidence: "explicit",
-        source,
-        attributes,
-        error
-      };
+  ]);
+}
+async function resolveInputUncached(input) {
+  if (input.type === "string") {
+    assertInputWithinBounds(input.content);
+    return { content: input.content, sourceFiles: [] };
+  }
+  if (input.type === "buffer") {
+    const content = input.content.toString("utf-8");
+    assertInputWithinBounds(content);
+    return { content, sourceFiles: [] };
+  }
+  if (input.type === "file") {
+    const content = await readFile(input.path, "utf-8");
+    assertInputWithinBounds(content, input.path);
+    return { content, sourceFiles: [input.path] };
+  }
+  if (input.type === "directory") {
+    const files = await jsonlFilesInDirectory(input.path);
+    const parts = await Promise.all(
+      files.map(async (file) => (await readFile(file, "utf-8")).trimEnd())
+    );
+    const content = parts.filter((part) => part.trim() !== "").join("\n");
+    assertInputWithinBounds(content, input.path);
+    return {
+      content,
+      sourceFiles: files
+    };
+  }
+  return void 0;
+}
+function detectJsonlFormat(content) {
+  let saw01 = false;
+  let saw02 = false;
+  let saw10 = false;
+  let validRows = 0;
+  let invalidJsonRows = 0;
+  let unknownSchemaRows = 0;
+  let firstInvalidJsonLine;
+  let firstUnknownSchemaLine;
+  let lineNumber = 0;
+  for (const line of content.split(/\r?\n/)) {
+    lineNumber += 1;
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      invalidJsonRows += 1;
+      firstInvalidJsonLine ??= lineNumber;
+      continue;
     }
-    case "step_started": {
-      const tsStart = toIsoTimestamp(event.startTime);
-      const tokenUsage = mapTokenUsageFromMetadata(event.metadata);
-      const attributes = compactAttributes2({
-        legacyEvent: "step_started",
-        stepId: event.stepId,
-        stepType: event.type,
-        metadata: event.metadata !== void 0 ? { ...event.metadata } : void 0,
-        invalidTimestamp: tsMain.invalidTimestamp || tsStart.invalidTimestamp ? true : void 0
-      });
-      const out = {
-        schemaVersion: "0.2",
-        eventId,
-        runId: event.runId,
-        kind: mapStepTypeToInspectKind(event.type),
-        name: event.name,
-        status: "running",
-        timestamp: tsMain.iso,
-        startedAt: tsStart.iso,
-        confidence: "explicit",
-        source,
-        attributes
-      };
-      if (event.parentId !== void 0) {
-        out.parentId = event.parentId;
-      }
-      if (tokenUsage !== void 0) {
-        out.tokenUsage = tokenUsage;
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "schemaVersion" in parsed) {
+      const version = parsed.schemaVersion;
+      if (version === "0.1") {
+        saw01 = true;
+        validRows += 1;
+        continue;
       }
-      return out;
-    }
-    case "step_completed": {
-      const tsEnd = toIsoTimestamp(event.endTime);
-      const { persisted: error, errorStack } = mapErrorInfo(event.error);
-      const attributes = compactAttributes2({
-        legacyEvent: "step_completed",
-        stepId: event.stepId,
-        errorStack,
-        invalidTimestamp: tsMain.invalidTimestamp || tsEnd.invalidTimestamp ? true : void 0
-      });
-      return {
-        schemaVersion: "0.2",
-        eventId,
-        runId: event.runId,
-        kind: "LOGIC",
-        name: event.stepId,
-        status: mapRunOrStepStatus(event.status),
-        timestamp: tsMain.iso,
-        endedAt: tsEnd.iso,
-        durationMs: event.durationMs,
-        confidence: "explicit",
-        source,
-        attributes,
-        error
-      };
-    }
-    case "outcome_observed": {
-      const tsObserved = toIsoTimestamp(event.observedAt);
-      const attributes = compactAttributes2({
-        legacyEvent: "outcome_observed",
-        outcomeId: event.outcomeId,
-        outcomeStatus: event.status,
-        expectation: event.expectation,
-        method: event.method,
-        actual: event.actual,
-        evidence: event.evidence,
-        observedAt: tsObserved.iso,
-        invalidTimestamp: tsMain.invalidTimestamp || tsObserved.invalidTimestamp ? true : void 0
-      });
-      const out = {
-        schemaVersion: "0.2",
-        eventId,
-        runId: event.runId,
-        kind: "OUTCOME",
-        name: event.name,
-        status: event.status === "failed" ? "error" : "ok",
-        timestamp: tsMain.iso,
-        confidence: "explicit",
-        source,
-        attributes
-      };
-      if (event.parentId !== void 0) {
-        out.parentId = event.parentId;
+      if (version === "0.2") {
+        saw02 = true;
+        validRows += 1;
+        continue;
       }
-      if (event.actual !== void 0) {
-        out.outputSummary = event.actual;
+      if (version === "1.0") {
+        saw10 = true;
+        validRows += 1;
+        continue;
       }
-      return out;
-    }
-    default: {
-      const _exhaustive = event;
-      throw new Error(`Unsupported trace event: ${_exhaustive.event}`);
     }
+    unknownSchemaRows += 1;
+    firstUnknownSchemaLine ??= lineNumber;
+  }
+  const warnings = [];
+  if (invalidJsonRows > 0) {
+    warnings.push({
+      code: "invalid_jsonl_rows",
+      message: `Skipped ${invalidJsonRows} invalid JSONL row(s) during format detection.`,
+      severity: "warning",
+      ...firstInvalidJsonLine !== void 0 ? { line: firstInvalidJsonLine } : {}
+    });
+  }
+  if (unknownSchemaRows > 0) {
+    warnings.push({
+      code: "unknown_schema_rows",
+      message: `Skipped ${unknownSchemaRows} row(s) with unknown schemaVersion during format detection.`,
+      severity: "warning",
+      ...firstUnknownSchemaLine !== void 0 ? { line: firstUnknownSchemaLine } : {}
+    });
   }
+  let format = "empty";
+  const seenFormats = [saw01, saw02, saw10].filter(Boolean).length;
+  if (seenFormats > 1) format = "mixed";
+  else if (saw01) format = "0.1";
+  else if (saw02) format = "0.2";
+  else if (saw10) format = "1.0";
+  return { format, validRows, warnings };
 }
-function traceEventsToPersistedInspectEvents(events, options) {
-  return events.map(
-    (event, index) => traceEventToPersistedInspectEvent(event, { ...options, eventIndex: index })
-  );
+function agentInspectFormatLabel(format) {
+  switch (format) {
+    case "0.1":
+      return "agent-inspect-v0.1-jsonl";
+    case "0.2":
+      return "agent-inspect-v0.2-jsonl";
+    case "1.0":
+      return "agent-inspect-v1.0-jsonl";
+    case "mixed":
+      return "agent-inspect-mixed-jsonl";
+    default:
+      return "agent-inspect-jsonl";
+  }
 }
-
-// packages/core/src/persisted/to-inspect-event.ts
-function compactAttributes3(entries) {
-  const out = {};
-  for (const [key, value] of Object.entries(entries)) {
-    if (value !== void 0) {
-      out[key] = value;
-    }
+function persistedEventsForParsedTrace(parsed) {
+  if ((parsed.format === "0.2" || parsed.format === "1.0") && parsed.persisted.length > 0) {
+    return [...parsed.persisted];
   }
-  return Object.keys(out).length > 0 ? out : void 0;
+  if (parsed.format === "mixed" && parsed.rows.length > 0) {
+    return parsed.rows.map((row, index) => {
+      if (row.format === "0.2" || row.format === "1.0") return row.event;
+      return traceEventToPersistedInspectEvent(row.event, {
+        eventIndex: index,
+        sourceName: "agent-inspect-jsonl-reader"
+      });
+    });
+  }
+  return traceEventsToPersistedInspectEvents(parsed.events, {
+    sourceName: "agent-inspect-jsonl-reader"
+  });
 }
-function parseIsoToMs3(iso) {
-  const parsed = Date.parse(iso);
-  if (!Number.isFinite(parsed)) {
-    return { ms: 0, invalidTimestamp: true };
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString3(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function readStringField(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (isNonEmptyString3(value)) return value;
   }
-  return { ms: parsed, invalidTimestamp: false };
+  return void 0;
 }
-function mapPersistedSourceToInspect(event) {
-  const attrs = event.attributes ?? {};
-  const sourceName = event.source.name;
-  if (sourceName === "pino") {
+function readRecordField(record, key) {
+  const value = record[key];
+  return isRecord6(value) ? value : void 0;
+}
+function parseJsonDocument(content) {
+  return JSON.parse(content);
+}
+function looksLikeOpenInferenceSpan(value) {
+  if (!isRecord6(value)) return false;
+  const attributes = readRecordField(value, "attributes");
+  return readStringField(value, ["trace_id", "traceId"]) !== void 0 && readStringField(value, ["span_id", "spanId"]) !== void 0 && (readStringField(value, ["name"]) !== void 0 || attributes?.["openinference.span.kind"] !== void 0);
+}
+function extractOpenInferenceDocument(root) {
+  const warnings = [];
+  const unsupportedFields = [];
+  if (Array.isArray(root)) {
+    const spans = root.filter(looksLikeOpenInferenceSpan);
+    if (spans.length === 0) return void 0;
+    if (spans.length !== root.length) {
+      warnings.push({
+        code: "openinference_skipped_items",
+        message: "Skipped non-span item(s) in OpenInference span array.",
+        severity: "warning"
+      });
+    }
     return {
-      type: "pino",
-      file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
-      line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
+      spans,
+      confidence: 0.82,
+      description: "OpenInference span array",
+      warnings,
+      unsupportedFields
     };
   }
-  if (sourceName === "winston") {
+  if (!isRecord6(root)) return void 0;
+  const rootFormat = root.format;
+  const rootCompatibility = root.compatibility;
+  const version = typeof root.version === "string" && root.version.trim() !== "" ? root.version : void 0;
+  if (Array.isArray(root.spans)) {
+    const spans = root.spans.filter(looksLikeOpenInferenceSpan);
+    if (spans.length === 0 && (rootFormat === "openinference" || rootCompatibility === "openinference-compatible")) {
+      warnings.push({
+        code: "openinference_no_valid_spans",
+        message: "OpenInference document did not contain any valid spans.",
+        severity: "error"
+      });
+      return {
+        spans,
+        confidence: 0.7,
+        description: "Malformed OpenInference document",
+        version,
+        warnings,
+        unsupportedFields
+      };
+    }
+    if (spans.length === 0) return void 0;
+    if (spans.length !== root.spans.length) {
+      warnings.push({
+        code: "openinference_skipped_spans",
+        message: "Skipped invalid OpenInference span item(s).",
+        severity: "warning"
+      });
+    }
     return {
-      type: "winston",
-      file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
-      line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
+      spans,
+      confidence: rootFormat === "openinference" || rootCompatibility === "openinference-compatible" ? 0.9 : 0.84,
+      description: rootFormat === "openinference" || rootCompatibility === "openinference-compatible" ? "OpenInference document" : "OpenInference spans document",
+      version,
+      warnings,
+      unsupportedFields
     };
   }
-  const mapType = (t) => {
-    switch (t) {
-      case "manual":
-        return "manual";
-      case "json-log":
-        return "json-log";
-      case "log4js":
-        return "log4js";
-      case "adapter":
-      case "ai-sdk":
-      case "otel":
-        return "adapter";
-      default:
-        return "json-log";
-    }
-  };
-  return {
-    type: mapType(event.source.type),
-    file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
-    line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
-  };
-}
-function buildInspectAttributes(event) {
-  const attrs = event.attributes !== void 0 ? { ...event.attributes } : {};
-  if (event.inputSummary !== void 0) {
-    attrs.inputSummary = event.inputSummary;
-  }
-  if (event.outputSummary !== void 0) {
-    attrs.outputSummary = event.outputSummary;
-  }
-  if (event.error) {
-    if (event.error.name !== void 0) {
-      attrs.errorName = event.error.name;
-    }
-    attrs.errorMessage = event.error.message;
-    if (event.error.code !== void 0) {
-      attrs.errorCode = event.error.code;
+  if (Array.isArray(root.data)) {
+    const spans = root.data.filter(looksLikeOpenInferenceSpan);
+    if (spans.length === 0) return void 0;
+    if (spans.length !== root.data.length) {
+      warnings.push({
+        code: "openinference_skipped_data_items",
+        message: "Skipped non-span item(s) in OpenInference data array.",
+        severity: "warning"
+      });
     }
+    return {
+      spans,
+      confidence: 0.8,
+      description: "OpenInference data document",
+      version,
+      warnings,
+      unsupportedFields
+    };
   }
-  if (event.tokenUsage) {
-    attrs.tokens = { ...event.tokenUsage };
-  }
-  if (event.source.type === "ai-sdk" || event.source.type === "otel") {
-    attrs.originalSourceType = event.source.type;
-  }
-  if (event.source.name !== void 0) {
-    attrs.sourceName = event.source.name;
-  }
-  if (event.source.version !== void 0) {
-    attrs.sourceVersion = event.source.version;
-  }
-  return attrs;
-}
-function persistedInspectEventToInspectEvent(event) {
-  if (!isPersistedInspectEvent(event)) {
-    throw new Error("Invalid PersistedInspectEvent: failed isPersistedInspectEvent");
-  }
-  const ts = parseIsoToMs3(event.timestamp);
-  const attrs = buildInspectAttributes(event);
-  if (ts.invalidTimestamp) {
-    attrs.invalidTimestamp = true;
-  }
-  let status;
-  if (event.status === "running" || event.status === "ok" || event.status === "error") {
-    status = event.status;
-  } else if (event.status === "unknown") {
-    attrs.persistedStatus = "unknown";
+  if (looksLikeOpenInferenceSpan(root)) {
+    return {
+      spans: [root],
+      confidence: 0.76,
+      description: "OpenInference single span",
+      version,
+      warnings,
+      unsupportedFields
+    };
   }
-  const out = {
-    eventId: event.eventId,
-    runId: event.runId,
-    name: event.name,
-    kind: event.kind,
-    timestamp: ts.ms,
-    confidence: event.confidence,
-    source: mapPersistedSourceToInspect(event),
-    attributes: compactAttributes3(attrs)
-  };
-  if (event.parentId !== void 0) {
-    out.parentId = event.parentId;
+  if (rootFormat === "openinference" || rootCompatibility === "openinference-compatible") {
+    warnings.push({
+      code: "openinference_missing_spans",
+      message: "OpenInference document is missing a spans array.",
+      severity: "error"
+    });
+    return {
+      spans: [],
+      confidence: 0.7,
+      description: "Malformed OpenInference document",
+      version,
+      warnings,
+      unsupportedFields
+    };
   }
-  if (status !== void 0) {
-    out.status = status;
+  return void 0;
+}
+function parseUnixNanoToIso(value) {
+  if (typeof value === "bigint" && value >= 0n) {
+    return new Date(Number(value / 1000000n)).toISOString();
   }
-  if (event.durationMs !== void 0 && Number.isFinite(event.durationMs) && event.durationMs >= 0) {
-    out.durationMs = event.durationMs;
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return new Date(Math.floor(value / 1e6)).toISOString();
   }
-  return out;
-}
-function persistedInspectEventsToInspectEvents(events, options) {
-  const skipInvalid = options?.skipInvalid === true;
-  const out = [];
-  for (const event of events) {
-    if (!isPersistedInspectEvent(event)) {
-      if (skipInvalid) {
-        continue;
-      }
-      throw new Error("Invalid PersistedInspectEvent: failed isPersistedInspectEvent");
-    }
-    out.push(persistedInspectEventToInspectEvent(event));
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    return new Date(Number(BigInt(value) / 1000000n)).toISOString();
   }
-  return out;
-}
-
-// packages/core/src/logs/tree-builder.ts
-function inc(map, key) {
-  map[key] = (map[key] ?? 0) + 1;
+  return void 0;
 }
-function computeRunStatus(events) {
-  let hasRunning = false;
-  for (const e of events) {
-    if (e.status === "error") return "error";
-    if (e.status === "running") hasRunning = true;
-  }
-  if (hasRunning) return "running";
-  return "ok";
+function parseIsoTime(value) {
+  if (!isNonEmptyString3(value)) return void 0;
+  const ms = Date.parse(value);
+  if (!Number.isFinite(ms)) return void 0;
+  return new Date(ms).toISOString();
 }
-var TreeBuilder = class {
-  constructor(options) {
-    void options?.config;
+function readOpenInferenceTimestamp(span, nanoKeys, isoKeys) {
+  for (const key of nanoKeys) {
+    const iso = parseUnixNanoToIso(span[key]);
+    if (iso !== void 0) return iso;
   }
-  build(events) {
-    const byRun = /* @__PURE__ */ new Map();
-    for (const e of events) {
-      if (!byRun.has(e.runId)) byRun.set(e.runId, []);
-      byRun.get(e.runId).push(e);
-    }
-    const out = [];
-    for (const [runId, runEvents] of byRun.entries()) {
-      const sorted = [...runEvents].sort((a, b) => a.timestamp - b.timestamp);
-      const nodes = /* @__PURE__ */ new Map();
-      for (const e of sorted) {
-        nodes.set(e.eventId, { event: e, children: [], depth: 0 });
-      }
-      const roots = [];
-      for (const node of nodes.values()) {
-        const parentId = node.event.parentId;
-        if (parentId && nodes.has(parentId)) {
-          nodes.get(parentId).children.push(node);
-        } else {
-          roots.push(node);
-        }
-      }
-      const assignDepth = (n, depth) => {
-        n.depth = depth;
-        for (const c of n.children) assignDepth(c, depth + 1);
-      };
-      for (const r of roots) assignDepth(r, 0);
-      const confidenceBreakdown = {
-        explicit: 0,
-        correlated: 0,
-        heuristic: 0,
-        unknown: 0
-      };
-      const kinds = {};
-      for (const e of sorted) {
-        inc(confidenceBreakdown, e.confidence);
-        kinds[e.kind] = (kinds[e.kind] ?? 0) + 1;
-      }
-      const startedAt = sorted.length > 0 ? sorted[0].timestamp : void 0;
-      const endedAt = sorted.length > 0 ? sorted[sorted.length - 1].timestamp : void 0;
-      const status = computeRunStatus(sorted);
-      const durationMs = startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt && status !== "running" ? endedAt - startedAt : void 0;
-      const name = sorted.find((e) => e.kind === "RUN")?.name;
-      out.push({
-        runId,
-        name,
-        status,
-        startedAt,
-        endedAt: status === "running" ? void 0 : endedAt,
-        durationMs,
-        children: roots,
-        metadata: {
-          totalEvents: sorted.length,
-          confidenceBreakdown,
-          kinds
-        }
-      });
-    }
-    out.sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0));
-    return out;
+  for (const key of isoKeys) {
+    const iso = parseIsoTime(span[key]);
+    if (iso !== void 0) return iso;
   }
-};
-
-// packages/core/src/persisted/tree-bridge.ts
-function persistedInspectEventsToRunTrees(events, options) {
-  const inspectEvents = persistedInspectEventsToInspectEvents(events, {
-    skipInvalid: options?.skipInvalid
-  });
-  return new TreeBuilder().build(inspectEvents);
+  return void 0;
 }
-var DEFAULT_MAX_TRACE_INPUT_BYTES = 10 * 1024 * 1024;
-var MIN_DETECTION_CONFIDENCE = 0.5;
-var AMBIGUOUS_CONFIDENCE_DELTA = 0.05;
-var resolvedInputCache = /* @__PURE__ */ new WeakMap();
-var OPENINFERENCE_READER_FORMAT = "openinference-json";
-var OTLP_READER_FORMAT = "otlp-json";
-var OPENINFERENCE_SPAN_KEYS = /* @__PURE__ */ new Set([
-  "trace_id",
-  "traceId",
-  "span_id",
-  "spanId",
-  "parent_span_id",
-  "parentSpanId",
-  "name",
-  "start_time_unix_nano",
-  "startTimeUnixNano",
-  "end_time_unix_nano",
-  "endTimeUnixNano",
-  "start_time",
-  "startTime",
-  "end_time",
-  "endTime",
-  "attributes",
-  "status",
-  "kind",
-  "span_kind",
-  "spanKind"
-]);
-var OPENINFERENCE_SENSITIVE_ATTRIBUTE_KEYS = [
-  "input.value",
-  "output.value",
-  "input.mime_type",
-  "output.mime_type",
-  "llm.input_messages",
-  "llm.output_messages",
-  "llm.prompts",
-  "llm.completions",
-  "retrieval.documents",
-  "reranker.input_documents",
-  "reranker.output_documents",
-  "document.content",
-  "gen_ai.prompt",
-  "gen_ai.completion",
-  "gen_ai.input.messages",
-  "gen_ai.output.messages"
-];
-var OTLP_SPAN_KEYS = /* @__PURE__ */ new Set([
-  "traceId",
-  "spanId",
-  "parentSpanId",
-  "name",
-  "kind",
-  "startTimeUnixNano",
-  "endTimeUnixNano",
-  "attributes",
-  "events",
-  "status",
-  "droppedAttributesCount",
-  "droppedEventsCount",
-  "droppedLinksCount",
-  "links",
-  "flags"
-]);
-var TraceReadError = class extends Error {
-  code;
-  warnings;
-  constructor(code, message, warnings = []) {
-    super(message);
-    this.name = "TraceReadError";
-    this.code = code;
-    this.warnings = warnings;
+function durationBetweenIso(startedAt, endedAt) {
+  if (startedAt === void 0 || endedAt === void 0) return void 0;
+  const startMs = Date.parse(startedAt);
+  const endMs = Date.parse(endedAt);
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs < startMs) {
+    return void 0;
   }
-};
-function normalizeCandidate(reader, candidate) {
-  const confidence = Number.isFinite(candidate.confidence) ? Math.max(0, Math.min(1, candidate.confidence)) : 0;
-  return {
-    ...candidate,
-    format: candidate.format || reader.format,
-    confidence,
-    readerName: candidate.readerName ?? reader.name
-  };
-}
-function sortCandidates(candidates) {
-  return [...candidates].sort((a, b) => {
-    if (b.confidence !== a.confidence) return b.confidence - a.confidence;
-    return a.format.localeCompare(b.format);
-  });
+  return endMs - startMs;
 }
-function collectWarnings(candidates) {
-  return candidates.flatMap((candidate) => candidate.warnings ?? []);
+function isSensitiveOpenInferenceAttribute(key) {
+  return OPENINFERENCE_SENSITIVE_ATTRIBUTE_KEYS.some(
+    (sensitiveKey) => key === sensitiveKey || key.startsWith(`${sensitiveKey}.`) || key.endsWith(".message.content") || key.endsWith(".document.content")
+  );
 }
-function dedupeWarnings(warnings) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const warning of warnings) {
-    const key = [
-      warning.code,
-      warning.message,
-      warning.severity ?? "",
-      warning.sourceFile ?? "",
-      warning.line ?? "",
-      warning.field ?? ""
-    ].join("\0");
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(warning);
+function summarizeAttributeValue(value) {
+  if (typeof value === "string") {
+    return { type: "string", length: value.length };
+  }
+  if (typeof value === "number") {
+    return { type: "number", finite: Number.isFinite(value) };
+  }
+  if (typeof value === "boolean") {
+    return { type: "boolean" };
+  }
+  if (Array.isArray(value)) {
+    return { type: "array", length: value.length };
+  }
+  if (isRecord6(value)) {
+    return { type: "object", keyCount: Object.keys(value).length };
   }
-  return out;
-}
-function attachSingleSourceFile(warnings, resolved) {
-  if (resolved.sourceFiles.length !== 1) return [...warnings];
-  const [sourceFile] = resolved.sourceFiles;
-  return warnings.map((warning) => ({
-    ...warning,
-    sourceFile: warning.sourceFile ?? sourceFile
-  }));
-}
-function findReaderByFormat(format, readers) {
-  return readers.find((reader) => reader.format === format);
+  if (value === null) {
+    return { type: "null" };
+  }
+  return { type: typeof value };
 }
-async function jsonlFilesInDirectory(dirPath) {
-  const entries = await readdir(dirPath, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
+function sanitizeOpenInferenceAttributes(attributes, pathPrefix) {
+  const out = {};
+  const warnings = [];
+  const unsupportedFields = [];
+  const summarizedKeys = [];
+  for (const [key, value] of Object.entries(attributes)) {
+    if (isSensitiveOpenInferenceAttribute(key)) {
+      summarizedKeys.push(key);
+      out[`${key}.summary`] = summarizeAttributeValue(value);
+      unsupportedFields.push(`${pathPrefix}.attributes.${key}`);
+      continue;
+    }
+    out[key] = value;
+  }
+  if (summarizedKeys.length > 0) {
+    out["openinference.summarized_attributes"] = summarizedKeys;
+    warnings.push({
+      code: "openinference_sensitive_attribute_summarized",
+      message: "OpenInference prompt/output/document attribute(s) were summarized instead of copied verbatim.",
+      severity: "warning"
+    });
+  }
+  return { attributes: out, warnings, unsupportedFields };
 }
-async function resolveInput(input) {
-  const cached = resolvedInputCache.get(input);
-  if (cached) return cached;
-  const promise = resolveInputUncached(input);
-  resolvedInputCache.set(input, promise);
-  return promise;
+function mapOpenInferenceKind(span, attributes, pathPrefix) {
+  const warnings = [];
+  const agentInspectKind = attributes["agent_inspect.kind"];
+  if (agentInspectKind === "RUN" || agentInspectKind === "AGENT" || agentInspectKind === "LLM" || agentInspectKind === "TOOL" || agentInspectKind === "CHAIN" || agentInspectKind === "RETRIEVER" || agentInspectKind === "DECISION" || agentInspectKind === "RESULT" || agentInspectKind === "ERROR" || agentInspectKind === "LOGIC" || agentInspectKind === "LOG" || agentInspectKind === "OUTCOME") {
+    return { kind: agentInspectKind, warnings };
+  }
+  const rawKind = readStringField(span, ["kind", "span_kind", "spanKind"]) ?? (typeof attributes["openinference.span.kind"] === "string" ? attributes["openinference.span.kind"] : void 0);
+  const normalized = rawKind?.toUpperCase();
+  switch (normalized) {
+    case "LLM":
+      return { kind: "LLM", warnings };
+    case "TOOL":
+      return { kind: "TOOL", warnings };
+    case "CHAIN":
+      return { kind: "CHAIN", warnings };
+    case "RETRIEVER":
+      return { kind: "RETRIEVER", warnings };
+    case "AGENT":
+      return { kind: "AGENT", warnings };
+    case "EMBEDDING":
+      warnings.push({
+        code: "openinference_kind_semantic_loss",
+        message: "OpenInference EMBEDDING span kind mapped to AgentInspect LLM.",
+        severity: "warning",
+        field: `${pathPrefix}.attributes.openinference.span.kind`
+      });
+      return { kind: "LLM", warnings };
+    case "RERANKER":
+      warnings.push({
+        code: "openinference_kind_semantic_loss",
+        message: "OpenInference RERANKER span kind mapped to AgentInspect RETRIEVER.",
+        severity: "warning",
+        field: `${pathPrefix}.attributes.openinference.span.kind`
+      });
+      return { kind: "RETRIEVER", warnings };
+    case "UNKNOWN":
+    case void 0:
+      warnings.push({
+        code: "openinference_kind_unknown",
+        message: "OpenInference span kind was missing or unknown; mapped to AgentInspect LOGIC.",
+        severity: "warning",
+        field: `${pathPrefix}.attributes.openinference.span.kind`
+      });
+      return { kind: "LOGIC", warnings };
+    default:
+      warnings.push({
+        code: "openinference_kind_unsupported",
+        message: `Unsupported OpenInference span kind "${rawKind}" mapped to AgentInspect LOGIC.`,
+        severity: "warning",
+        field: `${pathPrefix}.attributes.openinference.span.kind`
+      });
+      return { kind: "LOGIC", warnings };
+  }
 }
-function assertInputWithinBounds(content, sourceFile) {
-  const bytes = Buffer.byteLength(content, "utf8");
-  if (bytes <= DEFAULT_MAX_TRACE_INPUT_BYTES) return;
-  throw new TraceReadError("unsupported_format", "Trace input exceeds the local reader size limit.", [
-    {
-      code: "input_too_large",
-      message: `Trace input is ${bytes} bytes; max is ${DEFAULT_MAX_TRACE_INPUT_BYTES} bytes.`,
-      severity: "error",
-      ...sourceFile !== void 0 ? { sourceFile } : {}
-    }
-  ]);
+function mapOpenInferenceStatus(status) {
+  if (!isRecord6(status)) return void 0;
+  const rawCode = status.code;
+  if (typeof rawCode !== "string") return void 0;
+  switch (rawCode.toUpperCase()) {
+    case "OK":
+      return "ok";
+    case "ERROR":
+      return "error";
+    case "UNSET":
+      return "unknown";
+    default:
+      return "unknown";
+  }
 }
-async function resolveInputUncached(input) {
-  if (input.type === "string") {
-    assertInputWithinBounds(input.content);
-    return { content: input.content, sourceFiles: [] };
+function readOpenInferenceTokenUsage(attributes) {
+  const prompt = attributes["llm.token_count.prompt"];
+  const completion = attributes["llm.token_count.completion"];
+  const total = attributes["llm.token_count.total"];
+  const cached = attributes["llm.token_count.prompt_details.cache_read"];
+  const usage = {};
+  if (typeof prompt === "number" && Number.isFinite(prompt) && prompt >= 0) {
+    usage.input = prompt;
   }
-  if (input.type === "buffer") {
-    const content = input.content.toString("utf-8");
-    assertInputWithinBounds(content);
-    return { content, sourceFiles: [] };
+  if (typeof completion === "number" && Number.isFinite(completion) && completion >= 0) {
+    usage.output = completion;
   }
-  if (input.type === "file") {
-    const content = await readFile(input.path, "utf-8");
-    assertInputWithinBounds(content, input.path);
-    return { content, sourceFiles: [input.path] };
+  if (typeof total === "number" && Number.isFinite(total) && total >= 0) {
+    usage.total = total;
   }
-  if (input.type === "directory") {
-    const files = await jsonlFilesInDirectory(input.path);
-    const parts = await Promise.all(
-      files.map(async (file) => (await readFile(file, "utf-8")).trimEnd())
-    );
-    const content = parts.filter((part) => part.trim() !== "").join("\n");
-    assertInputWithinBounds(content, input.path);
-    return {
-      content,
-      sourceFiles: files
-    };
+  if (typeof cached === "number" && Number.isFinite(cached) && cached >= 0) {
+    usage.cached = cached;
   }
-  return void 0;
+  if (usage.total === void 0 && usage.input !== void 0 && usage.output !== void 0) {
+    usage.total = usage.input + usage.output;
+  }
+  return Object.keys(usage).length > 0 ? usage : void 0;
 }
-function detectJsonlFormat(content) {
-  let saw01 = false;
-  let saw02 = false;
-  let saw10 = false;
-  let validRows = 0;
-  let invalidJsonRows = 0;
-  let unknownSchemaRows = 0;
-  let firstInvalidJsonLine;
-  let firstUnknownSchemaLine;
-  let lineNumber = 0;
-  for (const line of content.split(/\r?\n/)) {
-    lineNumber += 1;
-    const trimmed = line.trim();
-    if (trimmed === "") continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      invalidJsonRows += 1;
-      firstInvalidJsonLine ??= lineNumber;
-      continue;
-    }
-    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "schemaVersion" in parsed) {
-      const version = parsed.schemaVersion;
-      if (version === "0.1") {
-        saw01 = true;
-        validRows += 1;
-        continue;
-      }
-      if (version === "0.2") {
-        saw02 = true;
-        validRows += 1;
-        continue;
-      }
-      if (version === "1.0") {
-        saw10 = true;
-        validRows += 1;
-        continue;
-      }
-    }
-    unknownSchemaRows += 1;
-    firstUnknownSchemaLine ??= lineNumber;
+function readOpenInferenceConfidence(attributes) {
+  const confidence = attributes["agent_inspect.confidence"];
+  if (confidence === "explicit" || confidence === "correlated" || confidence === "heuristic" || confidence === "unknown") {
+    return confidence;
   }
+  return "correlated";
+}
+function mapOpenInferenceSpan(span, index, version) {
+  const pathPrefix = `spans[${index}]`;
   const warnings = [];
-  if (invalidJsonRows > 0) {
+  const unsupportedFields = [];
+  const rawAttributes = readRecordField(span, "attributes") ?? {};
+  const sanitized = sanitizeOpenInferenceAttributes(rawAttributes, pathPrefix);
+  warnings.push(...sanitized.warnings);
+  unsupportedFields.push(...sanitized.unsupportedFields);
+  const attributes = { ...sanitized.attributes };
+  for (const [key, value] of Object.entries(span)) {
+    if (OPENINFERENCE_SPAN_KEYS.has(key)) continue;
+    unsupportedFields.push(`${pathPrefix}.${key}`);
+    if (value === null || typeof value !== "object") {
+      attributes[`openinference.${key}`] = value;
+    } else {
+      attributes[`openinference.${key}.summary`] = summarizeAttributeValue(value);
+      warnings.push({
+        code: "openinference_unsupported_field_summarized",
+        message: `Unsupported OpenInference span field "${key}" was summarized.`,
+        severity: "warning",
+        field: `${pathPrefix}.${key}`
+      });
+    }
+  }
+  const traceId = readStringField(span, ["trace_id", "traceId"]) ?? `trace-${index}`;
+  const spanId = readStringField(span, ["span_id", "spanId"]) ?? `span-${index}`;
+  const parentSpanId = readStringField(span, ["parent_span_id", "parentSpanId"]);
+  const name = readStringField(span, ["name"]) ?? spanId;
+  const startedAt = readOpenInferenceTimestamp(
+    span,
+    ["start_time_unix_nano", "startTimeUnixNano"],
+    ["start_time", "startTime"]
+  );
+  const endedAt = readOpenInferenceTimestamp(
+    span,
+    ["end_time_unix_nano", "endTimeUnixNano"],
+    ["end_time", "endTime"]
+  );
+  const timestamp = startedAt ?? "1970-01-01T00:00:00.000Z";
+  if (startedAt === void 0) {
     warnings.push({
-      code: "invalid_jsonl_rows",
-      message: `Skipped ${invalidJsonRows} invalid JSONL row(s) during format detection.`,
+      code: "openinference_missing_start_time",
+      message: "OpenInference span is missing a valid start time; using Unix epoch.",
       severity: "warning",
-      ...firstInvalidJsonLine !== void 0 ? { line: firstInvalidJsonLine } : {}
+      field: `${pathPrefix}.start_time_unix_nano`
     });
+    unsupportedFields.push(`${pathPrefix}.start_time_unix_nano`);
   }
-  if (unknownSchemaRows > 0) {
-    warnings.push({
-      code: "unknown_schema_rows",
-      message: `Skipped ${unknownSchemaRows} row(s) with unknown schemaVersion during format detection.`,
-      severity: "warning",
-      ...firstUnknownSchemaLine !== void 0 ? { line: firstUnknownSchemaLine } : {}
-    });
+  const { kind, warnings: kindWarnings } = mapOpenInferenceKind(
+    span,
+    rawAttributes,
+    pathPrefix
+  );
+  warnings.push(...kindWarnings);
+  const status = mapOpenInferenceStatus(span.status);
+  const tokenUsage = readOpenInferenceTokenUsage(rawAttributes);
+  const errorMessage = isRecord6(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
+  const event = {
+    schemaVersion: "0.2",
+    eventId: typeof rawAttributes["agent_inspect.event_id"] === "string" ? rawAttributes["agent_inspect.event_id"] : spanId,
+    runId: typeof rawAttributes["agent_inspect.run_id"] === "string" ? rawAttributes["agent_inspect.run_id"] : traceId,
+    kind,
+    name,
+    timestamp,
+    confidence: readOpenInferenceConfidence(rawAttributes),
+    source: {
+      type: "otel",
+      name: "openinference",
+      ...version !== void 0 ? { version } : {}
+    },
+    attributes,
+    trace: {
+      traceId,
+      spanId,
+      ...parentSpanId !== void 0 ? { parentSpanId } : {}
+    }
+  };
+  if (status !== void 0) {
+    event.status = status;
   }
-  let format = "empty";
-  const seenFormats = [saw01, saw02, saw10].filter(Boolean).length;
-  if (seenFormats > 1) format = "mixed";
-  else if (saw01) format = "0.1";
-  else if (saw02) format = "0.2";
-  else if (saw10) format = "1.0";
-  return { format, validRows, warnings };
-}
-function agentInspectFormatLabel(format) {
-  switch (format) {
-    case "0.1":
-      return "agent-inspect-v0.1-jsonl";
-    case "0.2":
-      return "agent-inspect-v0.2-jsonl";
-    case "1.0":
-      return "agent-inspect-v1.0-jsonl";
-    case "mixed":
-      return "agent-inspect-mixed-jsonl";
-    default:
-      return "agent-inspect-jsonl";
+  if (startedAt !== void 0) {
+    event.startedAt = startedAt;
   }
-}
-function persistedEventsForParsedTrace(parsed) {
-  if ((parsed.format === "0.2" || parsed.format === "1.0") && parsed.persisted.length > 0) {
-    return [...parsed.persisted];
+  if (endedAt !== void 0) {
+    event.endedAt = endedAt;
   }
-  if (parsed.format === "mixed" && parsed.rows.length > 0) {
-    return parsed.rows.map((row, index) => {
-      if (row.format === "0.2" || row.format === "1.0") return row.event;
-      return traceEventToPersistedInspectEvent(row.event, {
-        eventIndex: index,
-        sourceName: "agent-inspect-jsonl-reader"
-      });
-    });
+  const durationMs = durationBetweenIso(startedAt, endedAt);
+  if (durationMs !== void 0) {
+    event.durationMs = durationMs;
   }
-  return traceEventsToPersistedInspectEvents(parsed.events, {
-    sourceName: "agent-inspect-jsonl-reader"
-  });
-}
-function isRecord6(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isNonEmptyString3(value) {
-  return typeof value === "string" && value.trim() !== "";
-}
-function readStringField(record, keys) {
-  for (const key of keys) {
-    const value = record[key];
-    if (isNonEmptyString3(value)) return value;
+  if (tokenUsage !== void 0) {
+    event.tokenUsage = tokenUsage;
   }
-  return void 0;
-}
-function readRecordField(record, key) {
-  const value = record[key];
-  return isRecord6(value) ? value : void 0;
-}
-function parseJsonDocument(content) {
-  return JSON.parse(content);
+  if (status === "error") {
+    event.error = {
+      message: errorMessage !== void 0 && errorMessage.trim() !== "" ? errorMessage : "OpenInference span error"
+    };
+  }
+  return {
+    event,
+    warnings,
+    unsupportedFields,
+    spanId,
+    ...parentSpanId !== void 0 ? { parentSpanId } : {}
+  };
 }
-function looksLikeOpenInferenceSpan(value) {
-  if (!isRecord6(value)) return false;
-  const attributes = readRecordField(value, "attributes");
-  return readStringField(value, ["trace_id", "traceId"]) !== void 0 && readStringField(value, ["span_id", "spanId"]) !== void 0 && (readStringField(value, ["name"]) !== void 0 || attributes?.["openinference.span.kind"] !== void 0);
+function mapOpenInferenceEvents(document) {
+  const mapped = document.spans.map(
+    (span, index) => mapOpenInferenceSpan(span, index, document.version)
+  );
+  const spanIdToEventId = new Map(
+    mapped.map((span) => [span.spanId, span.event.eventId])
+  );
+  for (const span of mapped) {
+    if (span.parentSpanId === void 0) continue;
+    span.event.parentId = spanIdToEventId.get(span.parentSpanId) ?? span.parentSpanId;
+  }
+  return {
+    events: mapped.map((span) => span.event),
+    warnings: mapped.flatMap((span) => span.warnings),
+    unsupportedFields: mapped.flatMap((span) => span.unsupportedFields)
+  };
 }
-function extractOpenInferenceDocument(root) {
-  const warnings = [];
-  const unsupportedFields = [];
-  if (Array.isArray(root)) {
-    const spans = root.filter(looksLikeOpenInferenceSpan);
-    if (spans.length === 0) return void 0;
-    if (spans.length !== root.length) {
-      warnings.push({
-        code: "openinference_skipped_items",
-        message: "Skipped non-span item(s) in OpenInference span array.",
-        severity: "warning"
-      });
+var openInferenceJsonReader = {
+  format: OPENINFERENCE_READER_FORMAT,
+  name: "OpenInference JSON",
+  async detect(input) {
+    const resolved = await resolveInput(input);
+    if (!resolved) return void 0;
+    let parsed;
+    try {
+      parsed = parseJsonDocument(resolved.content);
+    } catch {
+      return void 0;
     }
+    const document = extractOpenInferenceDocument(parsed);
+    if (!document) return void 0;
     return {
-      spans,
-      confidence: 0.82,
-      description: "OpenInference span array",
-      warnings,
-      unsupportedFields
+      format: OPENINFERENCE_READER_FORMAT,
+      confidence: document.confidence,
+      readerName: "OpenInference JSON",
+      description: document.description,
+      warnings: attachSingleSourceFile(document.warnings, resolved)
     };
-  }
-  if (!isRecord6(root)) return void 0;
-  const rootFormat = root.format;
-  const rootCompatibility = root.compatibility;
-  const version = typeof root.version === "string" && root.version.trim() !== "" ? root.version : void 0;
-  if (Array.isArray(root.spans)) {
-    const spans = root.spans.filter(looksLikeOpenInferenceSpan);
-    if (spans.length === 0 && (rootFormat === "openinference" || rootCompatibility === "openinference-compatible")) {
-      warnings.push({
-        code: "openinference_no_valid_spans",
-        message: "OpenInference document did not contain any valid spans.",
-        severity: "error"
-      });
-      return {
-        spans,
-        confidence: 0.7,
-        description: "Malformed OpenInference document",
-        version,
-        warnings,
-        unsupportedFields
-      };
+  },
+  async read(input) {
+    const resolved = await resolveInput(input);
+    if (!resolved) {
+      throw new TraceReadError(
+        "unsupported_format",
+        "OpenInference JSON reader requires file, string, or buffer input."
+      );
     }
-    if (spans.length === 0) return void 0;
-    if (spans.length !== root.spans.length) {
-      warnings.push({
-        code: "openinference_skipped_spans",
-        message: "Skipped invalid OpenInference span item(s).",
-        severity: "warning"
-      });
+    let parsed;
+    try {
+      parsed = parseJsonDocument(resolved.content);
+    } catch {
+      throw new TraceReadError("unsupported_format", "OpenInference JSON input is not valid JSON.", [
+        {
+          code: "openinference_invalid_json",
+          message: "OpenInference JSON reader could not parse the input as JSON.",
+          severity: "error"
+        }
+      ]);
     }
-    return {
-      spans,
-      confidence: rootFormat === "openinference" || rootCompatibility === "openinference-compatible" ? 0.9 : 0.84,
-      description: rootFormat === "openinference" || rootCompatibility === "openinference-compatible" ? "OpenInference document" : "OpenInference spans document",
-      version,
-      warnings,
-      unsupportedFields
-    };
-  }
-  if (Array.isArray(root.data)) {
-    const spans = root.data.filter(looksLikeOpenInferenceSpan);
-    if (spans.length === 0) return void 0;
-    if (spans.length !== root.data.length) {
-      warnings.push({
-        code: "openinference_skipped_data_items",
-        message: "Skipped non-span item(s) in OpenInference data array.",
-        severity: "warning"
-      });
+    const document = extractOpenInferenceDocument(parsed);
+    if (!document || document.spans.length === 0) {
+      throw new TraceReadError(
+        "unsupported_format",
+        "No valid OpenInference spans found.",
+        attachSingleSourceFile(
+          document?.warnings ?? [
+            {
+              code: "openinference_no_valid_spans",
+              message: "OpenInference JSON input did not contain valid spans.",
+              severity: "error"
+            }
+          ],
+          resolved
+        )
+      );
     }
+    const mapped = mapOpenInferenceEvents(document);
+    const warnings = attachSingleSourceFile(
+      [...document.warnings, ...mapped.warnings],
+      resolved
+    );
+    const unsupportedFields = [
+      ...document.unsupportedFields,
+      ...mapped.unsupportedFields
+    ].sort((a, b) => a.localeCompare(b));
     return {
-      spans,
-      confidence: 0.8,
-      description: "OpenInference data document",
-      version,
-      warnings,
-      unsupportedFields
-    };
-  }
-  if (looksLikeOpenInferenceSpan(root)) {
-    return {
-      spans: [root],
-      confidence: 0.76,
-      description: "OpenInference single span",
-      version,
+      format: OPENINFERENCE_READER_FORMAT,
+      events: mapped.events,
+      runs: persistedInspectEventsToRunTrees(mapped.events, { skipInvalid: true }),
       warnings,
-      unsupportedFields
+      unsupportedFields,
+      sourceFiles: resolved.sourceFiles
     };
   }
-  if (rootFormat === "openinference" || rootCompatibility === "openinference-compatible") {
+};
+function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
+  if (!isRecord6(value)) {
+    unsupportedFields.push(field);
     warnings.push({
-      code: "openinference_missing_spans",
-      message: "OpenInference document is missing a spans array.",
-      severity: "error"
+      code: "otlp_attribute_value_invalid",
+      message: "OTLP attribute value was not an AnyValue object.",
+      severity: "warning",
+      field
     });
-    return {
-      spans: [],
-      confidence: 0.7,
-      description: "Malformed OpenInference document",
-      version,
-      warnings,
-      unsupportedFields
-    };
+    return void 0;
   }
-  return void 0;
-}
-function parseUnixNanoToIso(value) {
-  if (typeof value === "bigint" && value >= 0n) {
-    return new Date(Number(value / 1000000n)).toISOString();
+  if (typeof value.stringValue === "string") return value.stringValue;
+  if (typeof value.boolValue === "boolean") return value.boolValue;
+  if (typeof value.intValue === "number" && Number.isFinite(value.intValue)) {
+    return value.intValue;
   }
-  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
-    return new Date(Math.floor(value / 1e6)).toISOString();
+  if (typeof value.intValue === "string" && value.intValue.trim() !== "") {
+    const n = Number(value.intValue);
+    if (Number.isFinite(n)) return n;
   }
-  if (typeof value === "string" && /^\d+$/.test(value)) {
-    return new Date(Number(BigInt(value) / 1000000n)).toISOString();
+  if (typeof value.doubleValue === "number" && Number.isFinite(value.doubleValue)) {
+    return value.doubleValue;
   }
-  return void 0;
-}
-function parseIsoTime(value) {
-  if (!isNonEmptyString3(value)) return void 0;
-  const ms = Date.parse(value);
-  if (!Number.isFinite(ms)) return void 0;
-  return new Date(ms).toISOString();
-}
-function readOpenInferenceTimestamp(span, nanoKeys, isoKeys) {
-  for (const key of nanoKeys) {
-    const iso = parseUnixNanoToIso(span[key]);
-    if (iso !== void 0) return iso;
+  if (isRecord6(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
+    return value.arrayValue.values.map(
+      (item, index) => parseOtlpAnyValue(item, `${field}.arrayValue.values[${index}]`, warnings, unsupportedFields)
+    );
   }
-  for (const key of isoKeys) {
-    const iso = parseIsoTime(span[key]);
-    if (iso !== void 0) return iso;
+  if (isRecord6(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
+    const out = {};
+    for (const [index, item] of value.kvlistValue.values.entries()) {
+      if (!isRecord6(item) || typeof item.key !== "string") {
+        unsupportedFields.push(`${field}.kvlistValue.values[${index}]`);
+        continue;
+      }
+      out[item.key] = parseOtlpAnyValue(
+        item.value,
+        `${field}.kvlistValue.values[${index}].value`,
+        warnings,
+        unsupportedFields
+      );
+    }
+    return out;
   }
-  return void 0;
-}
-function durationBetweenIso(startedAt, endedAt) {
-  if (startedAt === void 0 || endedAt === void 0) return void 0;
-  const startMs = Date.parse(startedAt);
-  const endMs = Date.parse(endedAt);
-  if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs < startMs) {
-    return void 0;
+  if (typeof value.bytesValue === "string") {
+    unsupportedFields.push(field);
+    warnings.push({
+      code: "otlp_bytes_value_summarized",
+      message: "OTLP bytesValue attribute was summarized instead of decoded.",
+      severity: "warning",
+      field
+    });
+    return { type: "bytes", length: value.bytesValue.length };
   }
-  return endMs - startMs;
-}
-function isSensitiveOpenInferenceAttribute(key) {
-  return OPENINFERENCE_SENSITIVE_ATTRIBUTE_KEYS.some(
-    (sensitiveKey) => key === sensitiveKey || key.startsWith(`${sensitiveKey}.`) || key.endsWith(".message.content") || key.endsWith(".document.content")
-  );
+  unsupportedFields.push(field);
+  warnings.push({
+    code: "otlp_attribute_value_unsupported",
+    message: "OTLP attribute value used an unsupported AnyValue shape.",
+    severity: "warning",
+    field
+  });
+  return void 0;
 }
-function summarizeAttributeValue(value) {
-  if (typeof value === "string") {
-    return { type: "string", length: value.length };
-  }
-  if (typeof value === "number") {
-    return { type: "number", finite: Number.isFinite(value) };
-  }
-  if (typeof value === "boolean") {
-    return { type: "boolean" };
-  }
-  if (Array.isArray(value)) {
-    return { type: "array", length: value.length };
+function parseOtlpAttributes(value, pathPrefix) {
+  const attributes = {};
+  const warnings = [];
+  const unsupportedFields = [];
+  if (value === void 0) {
+    return { attributes, warnings, unsupportedFields };
   }
-  if (isRecord6(value)) {
-    return { type: "object", keyCount: Object.keys(value).length };
+  if (!Array.isArray(value)) {
+    unsupportedFields.push(pathPrefix);
+    warnings.push({
+      code: "otlp_attributes_invalid",
+      message: "OTLP attributes field was not an array.",
+      severity: "warning",
+      field: pathPrefix
+    });
+    return { attributes, warnings, unsupportedFields };
   }
-  if (value === null) {
-    return { type: "null" };
+  for (const [index, item] of value.entries()) {
+    const field = `${pathPrefix}[${index}]`;
+    if (!isRecord6(item) || typeof item.key !== "string") {
+      unsupportedFields.push(field);
+      warnings.push({
+        code: "otlp_attribute_invalid",
+        message: "Skipped OTLP attribute without a string key.",
+        severity: "warning",
+        field
+      });
+      continue;
+    }
+    const parsed = parseOtlpAnyValue(
+      item.value,
+      `${field}.value`,
+      warnings,
+      unsupportedFields
+    );
+    if (parsed !== void 0) {
+      attributes[item.key] = parsed;
+    }
   }
-  return { type: typeof value };
+  return { attributes, warnings, unsupportedFields };
 }
-function sanitizeOpenInferenceAttributes(attributes, pathPrefix) {
-  const out = {};
+function looksLikeOtlpSpan(value) {
+  return isRecord6(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
+}
+function extractOtlpDocument(root) {
+  if (!isRecord6(root) || !Array.isArray(root.resourceSpans)) return void 0;
+  const spans = [];
   const warnings = [];
   const unsupportedFields = [];
-  const summarizedKeys = [];
-  for (const [key, value] of Object.entries(attributes)) {
-    if (isSensitiveOpenInferenceAttribute(key)) {
-      summarizedKeys.push(key);
-      out[`${key}.summary`] = summarizeAttributeValue(value);
-      unsupportedFields.push(`${pathPrefix}.attributes.${key}`);
+  for (const [resourceIndex, resourceSpan] of root.resourceSpans.entries()) {
+    const resourcePath = `resourceSpans[${resourceIndex}]`;
+    if (!isRecord6(resourceSpan)) {
+      unsupportedFields.push(resourcePath);
+      continue;
+    }
+    const resource = readRecordField(resourceSpan, "resource");
+    const resourceParsed = parseOtlpAttributes(
+      resource?.attributes,
+      `${resourcePath}.resource.attributes`
+    );
+    warnings.push(...resourceParsed.warnings);
+    unsupportedFields.push(...resourceParsed.unsupportedFields);
+    if (!Array.isArray(resourceSpan.scopeSpans)) {
+      unsupportedFields.push(`${resourcePath}.scopeSpans`);
+      warnings.push({
+        code: "otlp_scope_spans_missing",
+        message: "OTLP resourceSpans entry did not contain a scopeSpans array.",
+        severity: "warning",
+        field: `${resourcePath}.scopeSpans`
+      });
       continue;
     }
-    out[key] = value;
+    for (const [scopeIndex, scopeSpan] of resourceSpan.scopeSpans.entries()) {
+      const scopePath = `${resourcePath}.scopeSpans[${scopeIndex}]`;
+      if (!isRecord6(scopeSpan)) {
+        unsupportedFields.push(scopePath);
+        continue;
+      }
+      const scope = readRecordField(scopeSpan, "scope");
+      const scopeParsed = parseOtlpAttributes(
+        scope?.attributes,
+        `${scopePath}.scope.attributes`
+      );
+      warnings.push(...scopeParsed.warnings);
+      unsupportedFields.push(...scopeParsed.unsupportedFields);
+      if (!Array.isArray(scopeSpan.spans)) {
+        unsupportedFields.push(`${scopePath}.spans`);
+        warnings.push({
+          code: "otlp_spans_missing",
+          message: "OTLP scopeSpans entry did not contain a spans array.",
+          severity: "warning",
+          field: `${scopePath}.spans`
+        });
+        continue;
+      }
+      for (const [spanIndex, span] of scopeSpan.spans.entries()) {
+        const spanPath = `${scopePath}.spans[${spanIndex}]`;
+        if (!looksLikeOtlpSpan(span)) {
+          unsupportedFields.push(spanPath);
+          warnings.push({
+            code: "otlp_invalid_span",
+            message: "Skipped OTLP span without required traceId, spanId, or name.",
+            severity: "warning",
+            field: spanPath
+          });
+          continue;
+        }
+        spans.push({
+          span,
+          resourceAttributes: resourceParsed.attributes,
+          scopeAttributes: scopeParsed.attributes,
+          scopeName: readStringField(scope ?? {}, ["name"]),
+          scopeVersion: readStringField(scope ?? {}, ["version"]),
+          pathPrefix: spanPath
+        });
+      }
+    }
   }
-  if (summarizedKeys.length > 0) {
-    out["openinference.summarized_attributes"] = summarizedKeys;
+  if (spans.length === 0) {
     warnings.push({
-      code: "openinference_sensitive_attribute_summarized",
-      message: "OpenInference prompt/output/document attribute(s) were summarized instead of copied verbatim.",
-      severity: "warning"
+      code: "otlp_no_valid_spans",
+      message: "OTLP JSON payload did not contain any valid spans.",
+      severity: "error"
     });
+    return {
+      spans,
+      confidence: 0.7,
+      description: "Malformed OTLP JSON trace payload",
+      warnings,
+      unsupportedFields
+    };
   }
-  return { attributes: out, warnings, unsupportedFields };
-}
-function mapOpenInferenceKind(span, attributes, pathPrefix) {
-  const warnings = [];
-  const agentInspectKind = attributes["agent_inspect.kind"];
-  if (agentInspectKind === "RUN" || agentInspectKind === "AGENT" || agentInspectKind === "LLM" || agentInspectKind === "TOOL" || agentInspectKind === "CHAIN" || agentInspectKind === "RETRIEVER" || agentInspectKind === "DECISION" || agentInspectKind === "RESULT" || agentInspectKind === "ERROR" || agentInspectKind === "LOGIC" || agentInspectKind === "LOG" || agentInspectKind === "OUTCOME") {
-    return { kind: agentInspectKind, warnings };
-  }
-  const rawKind = readStringField(span, ["kind", "span_kind", "spanKind"]) ?? (typeof attributes["openinference.span.kind"] === "string" ? attributes["openinference.span.kind"] : void 0);
-  const normalized = rawKind?.toUpperCase();
-  switch (normalized) {
-    case "LLM":
-      return { kind: "LLM", warnings };
-    case "TOOL":
-      return { kind: "TOOL", warnings };
-    case "CHAIN":
-      return { kind: "CHAIN", warnings };
-    case "RETRIEVER":
-      return { kind: "RETRIEVER", warnings };
-    case "AGENT":
-      return { kind: "AGENT", warnings };
-    case "EMBEDDING":
-      warnings.push({
-        code: "openinference_kind_semantic_loss",
-        message: "OpenInference EMBEDDING span kind mapped to AgentInspect LLM.",
-        severity: "warning",
-        field: `${pathPrefix}.attributes.openinference.span.kind`
-      });
-      return { kind: "LLM", warnings };
-    case "RERANKER":
-      warnings.push({
-        code: "openinference_kind_semantic_loss",
-        message: "OpenInference RERANKER span kind mapped to AgentInspect RETRIEVER.",
-        severity: "warning",
-        field: `${pathPrefix}.attributes.openinference.span.kind`
-      });
-      return { kind: "RETRIEVER", warnings };
-    case "UNKNOWN":
-    case void 0:
-      warnings.push({
-        code: "openinference_kind_unknown",
-        message: "OpenInference span kind was missing or unknown; mapped to AgentInspect LOGIC.",
-        severity: "warning",
-        field: `${pathPrefix}.attributes.openinference.span.kind`
-      });
-      return { kind: "LOGIC", warnings };
-    default:
-      warnings.push({
-        code: "openinference_kind_unsupported",
-        message: `Unsupported OpenInference span kind "${rawKind}" mapped to AgentInspect LOGIC.`,
-        severity: "warning",
-        field: `${pathPrefix}.attributes.openinference.span.kind`
-      });
-      return { kind: "LOGIC", warnings };
-  }
+  return {
+    spans,
+    confidence: 0.93,
+    description: "OTLP JSON trace payload",
+    warnings,
+    unsupportedFields
+  };
 }
-function mapOpenInferenceStatus(status) {
+function mapOtlpStatus(status) {
   if (!isRecord6(status)) return void 0;
   const rawCode = status.code;
   if (typeof rawCode !== "string") return void 0;
   switch (rawCode.toUpperCase()) {
+    case "STATUS_CODE_OK":
     case "OK":
       return "ok";
+    case "STATUS_CODE_ERROR":
     case "ERROR":
       return "error";
+    case "STATUS_CODE_UNSET":
     case "UNSET":
       return "unknown";
     default:
       return "unknown";
   }
 }
-function readOpenInferenceTokenUsage(attributes) {
-  const prompt = attributes["llm.token_count.prompt"];
-  const completion = attributes["llm.token_count.completion"];
-  const total = attributes["llm.token_count.total"];
-  const cached = attributes["llm.token_count.prompt_details.cache_read"];
-  const usage = {};
-  if (typeof prompt === "number" && Number.isFinite(prompt) && prompt >= 0) {
-    usage.input = prompt;
+function readOtlpKind(attributes, pathPrefix) {
+  const warnings = [];
+  const agentInspectKind = attributes["agent_inspect.kind"];
+  if (agentInspectKind === "RUN" || agentInspectKind === "AGENT" || agentInspectKind === "LLM" || agentInspectKind === "TOOL" || agentInspectKind === "CHAIN" || agentInspectKind === "RETRIEVER" || agentInspectKind === "DECISION" || agentInspectKind === "RESULT" || agentInspectKind === "ERROR" || agentInspectKind === "LOGIC" || agentInspectKind === "LOG" || agentInspectKind === "OUTCOME") {
+    return { kind: agentInspectKind, warnings };
   }
-  if (typeof completion === "number" && Number.isFinite(completion) && completion >= 0) {
-    usage.output = completion;
+  const operation = attributes["gen_ai.operation.name"];
+  if (typeof operation === "string") {
+    switch (operation) {
+      case "generate_content":
+      case "chat":
+        return { kind: "LLM", warnings };
+      case "execute_tool":
+        return { kind: "TOOL", warnings };
+      case "invoke_agent":
+        return { kind: "AGENT", warnings };
+      default:
+        warnings.push({
+          code: "otlp_gen_ai_operation_semantic_loss",
+          message: `OTLP GenAI operation "${operation}" mapped to AgentInspect LOGIC.`,
+          severity: "warning",
+          field: `${pathPrefix}.attributes.gen_ai.operation.name`
+        });
+        return { kind: "LOGIC", warnings };
+    }
   }
-  if (typeof total === "number" && Number.isFinite(total) && total >= 0) {
-    usage.total = total;
+  warnings.push({
+    code: "otlp_kind_unknown",
+    message: "OTLP span had no AgentInspect kind or GenAI operation; mapped to LOGIC.",
+    severity: "warning",
+    field: `${pathPrefix}.attributes`
+  });
+  return { kind: "LOGIC", warnings };
+}
+function readOtlpTokenUsage(attributes) {
+  const input = attributes["gen_ai.usage.input_tokens"];
+  const output = attributes["gen_ai.usage.output_tokens"];
+  const usage = {};
+  if (typeof input === "number" && Number.isFinite(input) && input >= 0) {
+    usage.input = input;
   }
-  if (typeof cached === "number" && Number.isFinite(cached) && cached >= 0) {
-    usage.cached = cached;
+  if (typeof output === "number" && Number.isFinite(output) && output >= 0) {
+    usage.output = output;
   }
-  if (usage.total === void 0 && usage.input !== void 0 && usage.output !== void 0) {
+  if (usage.input !== void 0 && usage.output !== void 0) {
     usage.total = usage.input + usage.output;
   }
   return Object.keys(usage).length > 0 ? usage : void 0;
 }
-function readOpenInferenceConfidence(attributes) {
-  const confidence = attributes["agent_inspect.confidence"];
-  if (confidence === "explicit" || confidence === "correlated" || confidence === "heuristic" || confidence === "unknown") {
-    return confidence;
+function readOtlpConfidence(attributes) {
+  return readOpenInferenceConfidence(attributes);
+}
+function sanitizeOtlpAttributes(attributes, pathPrefix) {
+  const ownerPath = pathPrefix.endsWith(".attributes") ? pathPrefix.slice(0, -".attributes".length) : pathPrefix;
+  const sanitized = sanitizeOpenInferenceAttributes(attributes, ownerPath);
+  return {
+    ...sanitized,
+    warnings: sanitized.warnings.map(
+      (warning) => warning.code === "openinference_sensitive_attribute_summarized" ? {
+        ...warning,
+        code: "otlp_sensitive_attribute_summarized",
+        message: "OTLP prompt/output/document attribute(s) were summarized instead of copied verbatim."
+      } : warning
+    )
+  };
+}
+function mapOtlpEvents(value, pathPrefix) {
+  const warnings = [];
+  const unsupportedFields = [];
+  if (value === void 0) return { warnings, unsupportedFields };
+  if (!Array.isArray(value)) {
+    unsupportedFields.push(pathPrefix);
+    warnings.push({
+      code: "otlp_events_invalid",
+      message: "OTLP events field was not an array.",
+      severity: "warning",
+      field: pathPrefix
+    });
+    return { warnings, unsupportedFields };
+  }
+  const events = [];
+  for (const [index, event] of value.entries()) {
+    const eventPath = `${pathPrefix}[${index}]`;
+    if (!isRecord6(event)) {
+      unsupportedFields.push(eventPath);
+      continue;
+    }
+    const parsedAttributes = parseOtlpAttributes(
+      event.attributes,
+      `${eventPath}.attributes`
+    );
+    warnings.push(...parsedAttributes.warnings);
+    unsupportedFields.push(...parsedAttributes.unsupportedFields);
+    const sanitized = sanitizeOtlpAttributes(
+      parsedAttributes.attributes,
+      `${eventPath}.attributes`
+    );
+    warnings.push(...sanitized.warnings);
+    unsupportedFields.push(...sanitized.unsupportedFields);
+    const out = {};
+    const name = readStringField(event, ["name"]);
+    if (name !== void 0) {
+      out.name = name;
+    }
+    const timestamp = parseUnixNanoToIso(event.timeUnixNano);
+    if (timestamp !== void 0) {
+      out.timestamp = timestamp;
+    } else if (event.timeUnixNano !== void 0) {
+      unsupportedFields.push(`${eventPath}.timeUnixNano`);
+      warnings.push({
+        code: "otlp_event_timestamp_invalid",
+        message: "OTLP event timeUnixNano could not be parsed.",
+        severity: "warning",
+        field: `${eventPath}.timeUnixNano`
+      });
+    }
+    if (Object.keys(sanitized.attributes).length > 0) {
+      out.attributes = sanitized.attributes;
+    }
+    events.push(out);
+  }
+  return {
+    events: events.length > 0 ? events : void 0,
+    warnings,
+    unsupportedFields
+  };
+}
+function mapOtlpSpan(context) {
+  const { span, pathPrefix } = context;
+  const warnings = [];
+  const unsupportedFields = [];
+  const parsedSpanAttributes = parseOtlpAttributes(
+    span.attributes,
+    `${pathPrefix}.attributes`
+  );
+  warnings.push(...parsedSpanAttributes.warnings);
+  unsupportedFields.push(...parsedSpanAttributes.unsupportedFields);
+  const sanitizedSpanAttributes = sanitizeOtlpAttributes(
+    parsedSpanAttributes.attributes,
+    `${pathPrefix}.attributes`
+  );
+  warnings.push(...sanitizedSpanAttributes.warnings);
+  unsupportedFields.push(...sanitizedSpanAttributes.unsupportedFields);
+  const attributes = {
+    ...sanitizedSpanAttributes.attributes
+  };
+  for (const [key, value] of Object.entries(context.resourceAttributes)) {
+    attributes[`resource.${key}`] = value;
+  }
+  for (const [key, value] of Object.entries(context.scopeAttributes)) {
+    attributes[`scope.${key}`] = value;
+  }
+  if (context.scopeName !== void 0) {
+    attributes["scope.name"] = context.scopeName;
+  }
+  if (context.scopeVersion !== void 0) {
+    attributes["scope.version"] = context.scopeVersion;
   }
-  return "correlated";
-}
-function mapOpenInferenceSpan(span, index, version) {
-  const pathPrefix = `spans[${index}]`;
-  const warnings = [];
-  const unsupportedFields = [];
-  const rawAttributes = readRecordField(span, "attributes") ?? {};
-  const sanitized = sanitizeOpenInferenceAttributes(rawAttributes, pathPrefix);
-  warnings.push(...sanitized.warnings);
-  unsupportedFields.push(...sanitized.unsupportedFields);
-  const attributes = { ...sanitized.attributes };
   for (const [key, value] of Object.entries(span)) {
-    if (OPENINFERENCE_SPAN_KEYS.has(key)) continue;
+    if (OTLP_SPAN_KEYS.has(key)) continue;
     unsupportedFields.push(`${pathPrefix}.${key}`);
     if (value === null || typeof value !== "object") {
-      attributes[`openinference.${key}`] = value;
+      attributes[`otlp.${key}`] = value;
     } else {
-      attributes[`openinference.${key}.summary`] = summarizeAttributeValue(value);
+      attributes[`otlp.${key}.summary`] = summarizeAttributeValue(value);
       warnings.push({
-        code: "openinference_unsupported_field_summarized",
-        message: `Unsupported OpenInference span field "${key}" was summarized.`,
+        code: "otlp_unsupported_field_summarized",
+        message: `Unsupported OTLP span field "${key}" was summarized.`,
         severity: "warning",
         field: `${pathPrefix}.${key}`
       });
     }
   }
-  const traceId = readStringField(span, ["trace_id", "traceId"]) ?? `trace-${index}`;
-  const spanId = readStringField(span, ["span_id", "spanId"]) ?? `span-${index}`;
-  const parentSpanId = readStringField(span, ["parent_span_id", "parentSpanId"]);
-  const name = readStringField(span, ["name"]) ?? spanId;
+  for (const key of [
+    "droppedAttributesCount",
+    "droppedEventsCount",
+    "droppedLinksCount",
+    "links"
+  ]) {
+    if (span[key] !== void 0) {
+      unsupportedFields.push(`${pathPrefix}.${key}`);
+      warnings.push({
+        code: "otlp_span_field_not_mapped",
+        message: `OTLP span field "${key}" is not represented in AgentInspect events.`,
+        severity: "warning",
+        field: `${pathPrefix}.${key}`
+      });
+    }
+  }
+  const events = mapOtlpEvents(span.events, `${pathPrefix}.events`);
+  warnings.push(...events.warnings);
+  unsupportedFields.push(...events.unsupportedFields);
+  if (events.events !== void 0) {
+    attributes["otlp.events"] = events.events;
+  }
+  const traceId = readStringField(span, ["traceId"]) ?? "trace-unknown";
+  const spanId = readStringField(span, ["spanId"]) ?? "span-unknown";
+  const parentSpanId = readStringField(span, ["parentSpanId"]);
   const startedAt = readOpenInferenceTimestamp(
     span,
-    ["start_time_unix_nano", "startTimeUnixNano"],
-    ["start_time", "startTime"]
-  );
-  const endedAt = readOpenInferenceTimestamp(
-    span,
-    ["end_time_unix_nano", "endTimeUnixNano"],
-    ["end_time", "endTime"]
+    ["startTimeUnixNano"],
+    []
   );
+  const endedAt = readOpenInferenceTimestamp(span, ["endTimeUnixNano"], []);
   const timestamp = startedAt ?? "1970-01-01T00:00:00.000Z";
   if (startedAt === void 0) {
+    unsupportedFields.push(`${pathPrefix}.startTimeUnixNano`);
     warnings.push({
-      code: "openinference_missing_start_time",
-      message: "OpenInference span is missing a valid start time; using Unix epoch.",
+      code: "otlp_missing_start_time",
+      message: "OTLP span is missing a valid startTimeUnixNano; using Unix epoch.",
       severity: "warning",
-      field: `${pathPrefix}.start_time_unix_nano`
+      field: `${pathPrefix}.startTimeUnixNano`
     });
-    unsupportedFields.push(`${pathPrefix}.start_time_unix_nano`);
   }
-  const { kind, warnings: kindWarnings } = mapOpenInferenceKind(
-    span,
-    rawAttributes,
+  const { kind, warnings: kindWarnings } = readOtlpKind(
+    parsedSpanAttributes.attributes,
     pathPrefix
   );
   warnings.push(...kindWarnings);
-  const status = mapOpenInferenceStatus(span.status);
-  const tokenUsage = readOpenInferenceTokenUsage(rawAttributes);
+  const status = mapOtlpStatus(span.status);
+  const tokenUsage = readOtlpTokenUsage(parsedSpanAttributes.attributes);
   const errorMessage = isRecord6(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
   const event = {
     schemaVersion: "0.2",
-    eventId: typeof rawAttributes["agent_inspect.event_id"] === "string" ? rawAttributes["agent_inspect.event_id"] : spanId,
-    runId: typeof rawAttributes["agent_inspect.run_id"] === "string" ? rawAttributes["agent_inspect.run_id"] : traceId,
+    eventId: typeof parsedSpanAttributes.attributes["agent_inspect.event_id"] === "string" ? parsedSpanAttributes.attributes["agent_inspect.event_id"] : spanId,
+    runId: typeof parsedSpanAttributes.attributes["agent_inspect.run_id"] === "string" ? parsedSpanAttributes.attributes["agent_inspect.run_id"] : traceId,
     kind,
-    name,
+    name: readStringField(span, ["name"]) ?? spanId,
     timestamp,
-    confidence: readOpenInferenceConfidence(rawAttributes),
+    confidence: readOtlpConfidence(parsedSpanAttributes.attributes),
     source: {
       type: "otel",
-      name: "openinference",
-      ...version !== void 0 ? { version } : {}
+      name: context.scopeName ?? (typeof context.resourceAttributes["service.name"] === "string" ? context.resourceAttributes["service.name"] : "otlp-json"),
+      ...context.scopeVersion !== void 0 ? { version: context.scopeVersion } : {}
     },
     attributes,
     trace: {
@@ -3378,7 +3401,7 @@ function mapOpenInferenceSpan(span, index, version) {
   }
   if (status === "error") {
     event.error = {
-      message: errorMessage !== void 0 && errorMessage.trim() !== "" ? errorMessage : "OpenInference span error"
+      message: errorMessage !== void 0 && errorMessage.trim() !== "" ? errorMessage : "OTLP span error"
     };
   }
   return {
@@ -3389,10 +3412,8 @@ function mapOpenInferenceSpan(span, index, version) {
     ...parentSpanId !== void 0 ? { parentSpanId } : {}
   };
 }
-function mapOpenInferenceEvents(document) {
-  const mapped = document.spans.map(
-    (span, index) => mapOpenInferenceSpan(span, index, document.version)
-  );
+function mapOtlpEventsToPersisted(document) {
+  const mapped = document.spans.map((span) => mapOtlpSpan(span));
   const spanIdToEventId = new Map(
     mapped.map((span) => [span.spanId, span.event.eventId])
   );
@@ -3406,9 +3427,9 @@ function mapOpenInferenceEvents(document) {
     unsupportedFields: mapped.flatMap((span) => span.unsupportedFields)
   };
 }
-var openInferenceJsonReader = {
-  format: OPENINFERENCE_READER_FORMAT,
-  name: "OpenInference JSON",
+var otlpJsonReader = {
+  format: OTLP_READER_FORMAT,
+  name: "OTLP JSON",
   async detect(input) {
     const resolved = await resolveInput(input);
     if (!resolved) return void 0;
@@ -3418,12 +3439,12 @@ var openInferenceJsonReader = {
     } catch {
       return void 0;
     }
-    const document = extractOpenInferenceDocument(parsed);
+    const document = extractOtlpDocument(parsed);
     if (!document) return void 0;
     return {
-      format: OPENINFERENCE_READER_FORMAT,
+      format: OTLP_READER_FORMAT,
       confidence: document.confidence,
-      readerName: "OpenInference JSON",
+      readerName: "OTLP JSON",
       description: document.description,
       warnings: attachSingleSourceFile(document.warnings, resolved)
     };
@@ -3433,31 +3454,31 @@ var openInferenceJsonReader = {
     if (!resolved) {
       throw new TraceReadError(
         "unsupported_format",
-        "OpenInference JSON reader requires file, string, or buffer input."
+        "OTLP JSON reader requires file, string, or buffer input."
       );
     }
     let parsed;
     try {
       parsed = parseJsonDocument(resolved.content);
     } catch {
-      throw new TraceReadError("unsupported_format", "OpenInference JSON input is not valid JSON.", [
+      throw new TraceReadError("unsupported_format", "OTLP JSON input is not valid JSON.", [
         {
-          code: "openinference_invalid_json",
-          message: "OpenInference JSON reader could not parse the input as JSON.",
+          code: "otlp_invalid_json",
+          message: "OTLP JSON reader could not parse the input as JSON.",
           severity: "error"
         }
       ]);
     }
-    const document = extractOpenInferenceDocument(parsed);
+    const document = extractOtlpDocument(parsed);
     if (!document || document.spans.length === 0) {
       throw new TraceReadError(
         "unsupported_format",
-        "No valid OpenInference spans found.",
+        "No valid OTLP spans found.",
         attachSingleSourceFile(
           document?.warnings ?? [
             {
-              code: "openinference_no_valid_spans",
-              message: "OpenInference JSON input did not contain valid spans.",
+              code: "otlp_no_valid_spans",
+              message: "OTLP JSON input did not contain valid spans.",
               severity: "error"
             }
           ],
@@ -3465,7 +3486,7 @@ var openInferenceJsonReader = {
         )
       );
     }
-    const mapped = mapOpenInferenceEvents(document);
+    const mapped = mapOtlpEventsToPersisted(document);
     const warnings = attachSingleSourceFile(
       [...document.warnings, ...mapped.warnings],
       resolved
@@ -3475,7 +3496,7 @@ var openInferenceJsonReader = {
       ...mapped.unsupportedFields
     ].sort((a, b) => a.localeCompare(b));
     return {
-      format: OPENINFERENCE_READER_FORMAT,
+      format: OTLP_READER_FORMAT,
       events: mapped.events,
       runs: persistedInspectEventsToRunTrees(mapped.events, { skipInvalid: true }),
       warnings,
@@ -3484,788 +3505,770 @@ var openInferenceJsonReader = {
     };
   }
 };
-function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
-  if (!isRecord6(value)) {
-    unsupportedFields.push(field);
-    warnings.push({
-      code: "otlp_attribute_value_invalid",
-      message: "OTLP attribute value was not an AnyValue object.",
-      severity: "warning",
-      field
-    });
-    return void 0;
-  }
-  if (typeof value.stringValue === "string") return value.stringValue;
-  if (typeof value.boolValue === "boolean") return value.boolValue;
-  if (typeof value.intValue === "number" && Number.isFinite(value.intValue)) {
-    return value.intValue;
-  }
-  if (typeof value.intValue === "string" && value.intValue.trim() !== "") {
-    const n = Number(value.intValue);
-    if (Number.isFinite(n)) return n;
-  }
-  if (typeof value.doubleValue === "number" && Number.isFinite(value.doubleValue)) {
-    return value.doubleValue;
-  }
-  if (isRecord6(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
-    return value.arrayValue.values.map(
-      (item, index) => parseOtlpAnyValue(item, `${field}.arrayValue.values[${index}]`, warnings, unsupportedFields)
-    );
-  }
-  if (isRecord6(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
-    const out = {};
-    for (const [index, item] of value.kvlistValue.values.entries()) {
-      if (!isRecord6(item) || typeof item.key !== "string") {
-        unsupportedFields.push(`${field}.kvlistValue.values[${index}]`);
-        continue;
-      }
-      out[item.key] = parseOtlpAnyValue(
-        item.value,
-        `${field}.kvlistValue.values[${index}].value`,
-        warnings,
-        unsupportedFields
-      );
+var agentInspectJsonlReader = {
+  format: "agent-inspect-jsonl",
+  name: "AgentInspect JSONL",
+  async detect(input) {
+    const resolved = await resolveInput(input);
+    if (!resolved) return void 0;
+    const detected = detectJsonlFormat(resolved.content);
+    if (detected.validRows === 0 || detected.format === "empty") {
+      return void 0;
     }
-    return out;
-  }
-  if (typeof value.bytesValue === "string") {
-    unsupportedFields.push(field);
-    warnings.push({
-      code: "otlp_bytes_value_summarized",
-      message: "OTLP bytesValue attribute was summarized instead of decoded.",
-      severity: "warning",
-      field
-    });
-    return { type: "bytes", length: value.bytesValue.length };
-  }
-  unsupportedFields.push(field);
-  warnings.push({
-    code: "otlp_attribute_value_unsupported",
-    message: "OTLP attribute value used an unsupported AnyValue shape.",
-    severity: "warning",
-    field
-  });
-  return void 0;
-}
-function parseOtlpAttributes(value, pathPrefix) {
-  const attributes = {};
-  const warnings = [];
-  const unsupportedFields = [];
-  if (value === void 0) {
-    return { attributes, warnings, unsupportedFields };
-  }
-  if (!Array.isArray(value)) {
-    unsupportedFields.push(pathPrefix);
-    warnings.push({
-      code: "otlp_attributes_invalid",
-      message: "OTLP attributes field was not an array.",
-      severity: "warning",
-      field: pathPrefix
-    });
-    return { attributes, warnings, unsupportedFields };
+    return {
+      format: "agent-inspect-jsonl",
+      confidence: 0.95,
+      readerName: "AgentInspect JSONL",
+      description: agentInspectFormatLabel(detected.format),
+      warnings: attachSingleSourceFile(detected.warnings, resolved)
+    };
+  },
+  async read(input) {
+    const resolved = await resolveInput(input);
+    if (!resolved) {
+      throw new Error("AgentInspect JSONL reader requires file, directory, string, or buffer input.");
+    }
+    const parsed = parseTraceJsonl(resolved.content, { warnings: false });
+    if (parsed.sourceEventCount === 0) {
+      throw new Error("No valid AgentInspect JSONL events found.");
+    }
+    const events = persistedEventsForParsedTrace(parsed);
+    return {
+      format: agentInspectFormatLabel(parsed.format),
+      events,
+      runs: persistedInspectEventsToRunTrees(events, { skipInvalid: true }),
+      warnings: parsed.format === "mixed" ? attachSingleSourceFile(
+        [
+          {
+            code: "mixed_agent_inspect_jsonl",
+            message: "Trace input mixes schemaVersion 0.1 and 0.2 rows; events were normalized for reading.",
+            severity: "warning"
+          }
+        ],
+        resolved
+      ) : [],
+      unsupportedFields: [],
+      sourceFiles: resolved.sourceFiles
+    };
   }
-  for (const [index, item] of value.entries()) {
-    const field = `${pathPrefix}[${index}]`;
-    if (!isRecord6(item) || typeof item.key !== "string") {
-      unsupportedFields.push(field);
-      warnings.push({
-        code: "otlp_attribute_invalid",
-        message: "Skipped OTLP attribute without a string key.",
-        severity: "warning",
-        field
-      });
-      continue;
-    }
-    const parsed = parseOtlpAnyValue(
-      item.value,
-      `${field}.value`,
-      warnings,
-      unsupportedFields
-    );
-    if (parsed !== void 0) {
-      attributes[item.key] = parsed;
+};
+var DEFAULT_TRACE_READERS = [
+  agentInspectJsonlReader,
+  openInferenceJsonReader,
+  otlpJsonReader
+];
+async function detectTraceFormat(input, options = {}) {
+  const readers = options.readers ?? DEFAULT_TRACE_READERS;
+  if (options.format !== void 0) {
+    const reader = findReaderByFormat(options.format, readers);
+    if (!reader) {
+      return {
+        status: "unsupported",
+        candidates: [],
+        warnings: [
+          {
+            code: "unsupported_format",
+            message: `No trace reader is registered for format "${options.format}".`,
+            severity: "error"
+          }
+        ]
+      };
     }
+    return {
+      status: "detected",
+      format: reader.format,
+      candidates: [
+        {
+          format: reader.format,
+          confidence: 1,
+          readerName: reader.name,
+          description: "Explicit format override"
+        }
+      ],
+      warnings: []
+    };
   }
-  return { attributes, warnings, unsupportedFields };
-}
-function looksLikeOtlpSpan(value) {
-  return isRecord6(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
-}
-function extractOtlpDocument(root) {
-  if (!isRecord6(root) || !Array.isArray(root.resourceSpans)) return void 0;
-  const spans = [];
+  const candidates = [];
   const warnings = [];
-  const unsupportedFields = [];
-  for (const [resourceIndex, resourceSpan] of root.resourceSpans.entries()) {
-    const resourcePath = `resourceSpans[${resourceIndex}]`;
-    if (!isRecord6(resourceSpan)) {
-      unsupportedFields.push(resourcePath);
-      continue;
-    }
-    const resource = readRecordField(resourceSpan, "resource");
-    const resourceParsed = parseOtlpAttributes(
-      resource?.attributes,
-      `${resourcePath}.resource.attributes`
-    );
-    warnings.push(...resourceParsed.warnings);
-    unsupportedFields.push(...resourceParsed.unsupportedFields);
-    if (!Array.isArray(resourceSpan.scopeSpans)) {
-      unsupportedFields.push(`${resourcePath}.scopeSpans`);
-      warnings.push({
-        code: "otlp_scope_spans_missing",
-        message: "OTLP resourceSpans entry did not contain a scopeSpans array.",
-        severity: "warning",
-        field: `${resourcePath}.scopeSpans`
-      });
-      continue;
-    }
-    for (const [scopeIndex, scopeSpan] of resourceSpan.scopeSpans.entries()) {
-      const scopePath = `${resourcePath}.scopeSpans[${scopeIndex}]`;
-      if (!isRecord6(scopeSpan)) {
-        unsupportedFields.push(scopePath);
-        continue;
+  for (const reader of readers) {
+    try {
+      const candidate = await reader.detect(input);
+      if (candidate !== void 0) {
+        candidates.push(normalizeCandidate(reader, candidate));
       }
-      const scope = readRecordField(scopeSpan, "scope");
-      const scopeParsed = parseOtlpAttributes(
-        scope?.attributes,
-        `${scopePath}.scope.attributes`
-      );
-      warnings.push(...scopeParsed.warnings);
-      unsupportedFields.push(...scopeParsed.unsupportedFields);
-      if (!Array.isArray(scopeSpan.spans)) {
-        unsupportedFields.push(`${scopePath}.spans`);
-        warnings.push({
-          code: "otlp_spans_missing",
-          message: "OTLP scopeSpans entry did not contain a spans array.",
-          severity: "warning",
-          field: `${scopePath}.spans`
-        });
+    } catch (error) {
+      if (error instanceof TraceReadError) {
+        warnings.push(...error.warnings);
         continue;
       }
-      for (const [spanIndex, span] of scopeSpan.spans.entries()) {
-        const spanPath = `${scopePath}.spans[${spanIndex}]`;
-        if (!looksLikeOtlpSpan(span)) {
-          unsupportedFields.push(spanPath);
-          warnings.push({
-            code: "otlp_invalid_span",
-            message: "Skipped OTLP span without required traceId, spanId, or name.",
-            severity: "warning",
-            field: spanPath
-          });
-          continue;
-        }
-        spans.push({
-          span,
-          resourceAttributes: resourceParsed.attributes,
-          scopeAttributes: scopeParsed.attributes,
-          scopeName: readStringField(scope ?? {}, ["name"]),
-          scopeVersion: readStringField(scope ?? {}, ["version"]),
-          pathPrefix: spanPath
-        });
-      }
+      warnings.push({
+        code: "reader_detect_failed",
+        message: error instanceof Error && error.message.trim() !== "" ? error.message : `Trace reader "${reader.format}" failed during detection.`,
+        severity: "warning"
+      });
     }
   }
-  if (spans.length === 0) {
-    warnings.push({
-      code: "otlp_no_valid_spans",
-      message: "OTLP JSON payload did not contain any valid spans.",
-      severity: "error"
-    });
+  const sorted = sortCandidates(
+    candidates.filter((candidate) => candidate.confidence >= MIN_DETECTION_CONFIDENCE)
+  );
+  const candidateWarnings = collectWarnings(sorted);
+  const lowConfidenceWarnings = candidates.length > sorted.length ? [
+    {
+      code: "low_confidence_candidates",
+      message: `Ignored ${candidates.length - sorted.length} low-confidence format candidate(s).`,
+      severity: "info"
+    }
+  ] : [];
+  const allWarnings = dedupeWarnings([
+    ...warnings,
+    ...candidateWarnings,
+    ...lowConfidenceWarnings
+  ]);
+  if (sorted.length === 0) {
     return {
-      spans,
-      confidence: 0.7,
-      description: "Malformed OTLP JSON trace payload",
-      warnings,
-      unsupportedFields
+      status: "unsupported",
+      candidates: [],
+      warnings: allWarnings
     };
   }
-  return {
-    spans,
-    confidence: 0.93,
-    description: "OTLP JSON trace payload",
-    warnings,
-    unsupportedFields
-  };
-}
-function mapOtlpStatus(status) {
-  if (!isRecord6(status)) return void 0;
-  const rawCode = status.code;
-  if (typeof rawCode !== "string") return void 0;
-  switch (rawCode.toUpperCase()) {
-    case "STATUS_CODE_OK":
-    case "OK":
-      return "ok";
-    case "STATUS_CODE_ERROR":
-    case "ERROR":
-      return "error";
-    case "STATUS_CODE_UNSET":
-    case "UNSET":
-      return "unknown";
-    default:
-      return "unknown";
-  }
-}
-function readOtlpKind(attributes, pathPrefix) {
-  const warnings = [];
-  const agentInspectKind = attributes["agent_inspect.kind"];
-  if (agentInspectKind === "RUN" || agentInspectKind === "AGENT" || agentInspectKind === "LLM" || agentInspectKind === "TOOL" || agentInspectKind === "CHAIN" || agentInspectKind === "RETRIEVER" || agentInspectKind === "DECISION" || agentInspectKind === "RESULT" || agentInspectKind === "ERROR" || agentInspectKind === "LOGIC" || agentInspectKind === "LOG" || agentInspectKind === "OUTCOME") {
-    return { kind: agentInspectKind, warnings };
-  }
-  const operation = attributes["gen_ai.operation.name"];
-  if (typeof operation === "string") {
-    switch (operation) {
-      case "generate_content":
-      case "chat":
-        return { kind: "LLM", warnings };
-      case "execute_tool":
-        return { kind: "TOOL", warnings };
-      case "invoke_agent":
-        return { kind: "AGENT", warnings };
-      default:
-        warnings.push({
-          code: "otlp_gen_ai_operation_semantic_loss",
-          message: `OTLP GenAI operation "${operation}" mapped to AgentInspect LOGIC.`,
-          severity: "warning",
-          field: `${pathPrefix}.attributes.gen_ai.operation.name`
-        });
-        return { kind: "LOGIC", warnings };
-    }
-  }
-  warnings.push({
-    code: "otlp_kind_unknown",
-    message: "OTLP span had no AgentInspect kind or GenAI operation; mapped to LOGIC.",
-    severity: "warning",
-    field: `${pathPrefix}.attributes`
-  });
-  return { kind: "LOGIC", warnings };
-}
-function readOtlpTokenUsage(attributes) {
-  const input = attributes["gen_ai.usage.input_tokens"];
-  const output = attributes["gen_ai.usage.output_tokens"];
-  const usage = {};
-  if (typeof input === "number" && Number.isFinite(input) && input >= 0) {
-    usage.input = input;
-  }
-  if (typeof output === "number" && Number.isFinite(output) && output >= 0) {
-    usage.output = output;
-  }
-  if (usage.input !== void 0 && usage.output !== void 0) {
-    usage.total = usage.input + usage.output;
+  const [best, second] = sorted;
+  if (second !== void 0 && best.confidence - second.confidence <= AMBIGUOUS_CONFIDENCE_DELTA) {
+    return {
+      status: "ambiguous",
+      candidates: sorted,
+      warnings: [
+        ...allWarnings,
+        {
+          code: "ambiguous_format_candidates",
+          message: `Top trace format candidates are within ${AMBIGUOUS_CONFIDENCE_DELTA} confidence.`,
+          severity: "warning"
+        }
+      ]
+    };
   }
-  return Object.keys(usage).length > 0 ? usage : void 0;
-}
-function readOtlpConfidence(attributes) {
-  return readOpenInferenceConfidence(attributes);
-}
-function sanitizeOtlpAttributes(attributes, pathPrefix) {
-  const ownerPath = pathPrefix.endsWith(".attributes") ? pathPrefix.slice(0, -".attributes".length) : pathPrefix;
-  const sanitized = sanitizeOpenInferenceAttributes(attributes, ownerPath);
   return {
-    ...sanitized,
-    warnings: sanitized.warnings.map(
-      (warning) => warning.code === "openinference_sensitive_attribute_summarized" ? {
-        ...warning,
-        code: "otlp_sensitive_attribute_summarized",
-        message: "OTLP prompt/output/document attribute(s) were summarized instead of copied verbatim."
-      } : warning
-    )
+    status: "detected",
+    format: best.format,
+    candidates: sorted,
+    warnings: allWarnings
   };
 }
-function mapOtlpEvents(value, pathPrefix) {
-  const warnings = [];
-  const unsupportedFields = [];
-  if (value === void 0) return { warnings, unsupportedFields };
-  if (!Array.isArray(value)) {
-    unsupportedFields.push(pathPrefix);
-    warnings.push({
-      code: "otlp_events_invalid",
-      message: "OTLP events field was not an array.",
-      severity: "warning",
-      field: pathPrefix
-    });
-    return { warnings, unsupportedFields };
+async function readTrace(input, options = {}) {
+  const readers = options.readers ?? DEFAULT_TRACE_READERS;
+  const detection = await detectTraceFormat(input, options);
+  if (detection.status === "unsupported" || detection.format === void 0) {
+    throw new TraceReadError(
+      "unsupported_format",
+      "No trace reader could detect the input format.",
+      detection.warnings
+    );
   }
-  const events = [];
-  for (const [index, event] of value.entries()) {
-    const eventPath = `${pathPrefix}[${index}]`;
-    if (!isRecord6(event)) {
-      unsupportedFields.push(eventPath);
-      continue;
-    }
-    const parsedAttributes = parseOtlpAttributes(
-      event.attributes,
-      `${eventPath}.attributes`
+  if (detection.status === "ambiguous") {
+    throw new TraceReadError(
+      "ambiguous_format",
+      "Multiple trace readers matched the input with equal confidence.",
+      detection.warnings
     );
-    warnings.push(...parsedAttributes.warnings);
-    unsupportedFields.push(...parsedAttributes.unsupportedFields);
-    const sanitized = sanitizeOtlpAttributes(
-      parsedAttributes.attributes,
-      `${eventPath}.attributes`
+  }
+  const reader = findReaderByFormat(detection.format, readers);
+  if (!reader) {
+    throw new TraceReadError(
+      "unsupported_format",
+      `No trace reader is registered for format "${detection.format}".`,
+      detection.warnings
     );
-    warnings.push(...sanitized.warnings);
-    unsupportedFields.push(...sanitized.unsupportedFields);
-    const out = {};
-    const name = readStringField(event, ["name"]);
-    if (name !== void 0) {
-      out.name = name;
-    }
-    const timestamp = parseUnixNanoToIso(event.timeUnixNano);
-    if (timestamp !== void 0) {
-      out.timestamp = timestamp;
-    } else if (event.timeUnixNano !== void 0) {
-      unsupportedFields.push(`${eventPath}.timeUnixNano`);
-      warnings.push({
-        code: "otlp_event_timestamp_invalid",
-        message: "OTLP event timeUnixNano could not be parsed.",
-        severity: "warning",
-        field: `${eventPath}.timeUnixNano`
-      });
-    }
-    if (Object.keys(sanitized.attributes).length > 0) {
-      out.attributes = sanitized.attributes;
+  }
+  try {
+    const result = await reader.read(input, { format: detection.format });
+    return {
+      ...result,
+      format: result.format || detection.format,
+      warnings: [...detection.warnings, ...result.warnings]
+    };
+  } catch (error) {
+    if (error instanceof TraceReadError) {
+      throw new TraceReadError(
+        error.code,
+        error.message,
+        dedupeWarnings([...detection.warnings, ...error.warnings])
+      );
     }
-    events.push(out);
+    throw new TraceReadError(
+      "reader_failed",
+      error instanceof Error && error.message.trim() !== "" ? error.message : `Trace reader "${reader.format}" failed.`,
+      detection.warnings
+    );
   }
-  return {
-    events: events.length > 0 ? events : void 0,
-    warnings,
-    unsupportedFields
-  };
 }
-function mapOtlpSpan(context) {
-  const { span, pathPrefix } = context;
-  const warnings = [];
-  const unsupportedFields = [];
-  const parsedSpanAttributes = parseOtlpAttributes(
-    span.attributes,
-    `${pathPrefix}.attributes`
-  );
-  warnings.push(...parsedSpanAttributes.warnings);
-  unsupportedFields.push(...parsedSpanAttributes.unsupportedFields);
-  const sanitizedSpanAttributes = sanitizeOtlpAttributes(
-    parsedSpanAttributes.attributes,
-    `${pathPrefix}.attributes`
-  );
-  warnings.push(...sanitizedSpanAttributes.warnings);
-  unsupportedFields.push(...sanitizedSpanAttributes.unsupportedFields);
-  const attributes = {
-    ...sanitizedSpanAttributes.attributes
-  };
-  for (const [key, value] of Object.entries(context.resourceAttributes)) {
-    attributes[`resource.${key}`] = value;
-  }
-  for (const [key, value] of Object.entries(context.scopeAttributes)) {
-    attributes[`scope.${key}`] = value;
+function openTrace(input, options = {}) {
+  return readTrace(input, options);
+}
+
+// packages/core/src/exporters/helpers.ts
+var REDACT_SUBSTRINGS = [
+  "authorization",
+  "cookie",
+  "token",
+  "apikey",
+  "password",
+  "secret",
+  "email"
+];
+function shouldRedactKey(key) {
+  const k = key.toLowerCase();
+  for (const s of REDACT_SUBSTRINGS) {
+    if (k.includes(s)) return true;
   }
-  if (context.scopeName !== void 0) {
-    attributes["scope.name"] = context.scopeName;
+  return false;
+}
+function safeString(value, maxLength) {
+  if (value === null || value === void 0) return "";
+  let s;
+  if (typeof value === "string") s = value;
+  else if (typeof value === "number" || typeof value === "boolean") s = String(value);
+  else s = stableJson(value, false);
+  if (maxLength !== void 0 && maxLength >= 0 && s.length > maxLength) {
+    return `${s.slice(0, maxLength)}\u2026`;
   }
-  if (context.scopeVersion !== void 0) {
-    attributes["scope.version"] = context.scopeVersion;
+  return s;
+}
+function escapeMarkdown(value) {
+  return value.replace(/\|/g, "\\|").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, " ");
+}
+function sortKeysDeep(input) {
+  if (input === null || typeof input !== "object") return input;
+  if (Array.isArray(input)) return input.map(sortKeysDeep);
+  const o = input;
+  const out = {};
+  for (const k of Object.keys(o).sort()) {
+    out[k] = sortKeysDeep(o[k]);
   }
-  for (const [key, value] of Object.entries(span)) {
-    if (OTLP_SPAN_KEYS.has(key)) continue;
-    unsupportedFields.push(`${pathPrefix}.${key}`);
-    if (value === null || typeof value !== "object") {
-      attributes[`otlp.${key}`] = value;
-    } else {
-      attributes[`otlp.${key}.summary`] = summarizeAttributeValue(value);
-      warnings.push({
-        code: "otlp_unsupported_field_summarized",
-        message: `Unsupported OTLP span field "${key}" was summarized.`,
-        severity: "warning",
-        field: `${pathPrefix}.${key}`
-      });
+  return out;
+}
+function stableJson(value, pretty) {
+  const sorted = sortKeysDeep(value);
+  return pretty === true ? JSON.stringify(sorted, null, 2) : JSON.stringify(sorted);
+}
+function compactAttributes3(attrs, options) {
+  if (attrs === void 0) return {};
+  const maxLen = options?.maxLength ?? 500;
+  const out = {};
+  for (const key of Object.keys(attrs).sort()) {
+    if (shouldRedactKey(key)) {
+      out[key] = "[REDACTED]";
+      continue;
     }
+    const v = attrs[key];
+    out[key] = compactValue(v, maxLen);
   }
-  for (const key of [
-    "droppedAttributesCount",
-    "droppedEventsCount",
-    "droppedLinksCount",
-    "links"
-  ]) {
-    if (span[key] !== void 0) {
-      unsupportedFields.push(`${pathPrefix}.${key}`);
-      warnings.push({
-        code: "otlp_span_field_not_mapped",
-        message: `OTLP span field "${key}" is not represented in AgentInspect events.`,
-        severity: "warning",
-        field: `${pathPrefix}.${key}`
-      });
+  return out;
+}
+function compactValue(value, maxLen, redacted) {
+  if (value === null || typeof value !== "object") {
+    return typeof value === "string" ? safeString(value, maxLen) : value;
+  }
+  if (Array.isArray(value)) {
+    const arr = value.slice(0, 20).map((x) => compactValue(x, maxLen));
+    if (value.length > 20) arr.push(`\u2026(+${value.length - 20} more)`);
+    return arr;
+  }
+  const o = value;
+  const inner = {};
+  for (const k of Object.keys(o)) {
+    if (shouldRedactKey(k)) inner[k] = "[REDACTED]";
+    else inner[k] = compactValue(o[k], maxLen);
+  }
+  return inner;
+}
+function flattenTree(tree) {
+  const out = [];
+  function walk(nodes) {
+    for (const n of nodes) {
+      out.push(n);
+      if (n.children.length > 0) walk(n.children);
     }
   }
-  const events = mapOtlpEvents(span.events, `${pathPrefix}.events`);
-  warnings.push(...events.warnings);
-  unsupportedFields.push(...events.unsupportedFields);
-  if (events.events !== void 0) {
-    attributes["otlp.events"] = events.events;
+  walk(tree.children);
+  return out;
+}
+
+// packages/core/src/diff/comparable.ts
+function extractOutputPreview(meta) {
+  if (meta === void 0) return void 0;
+  if ("outputPreview" in meta) return meta.outputPreview;
+  if ("resultPreview" in meta) return meta.resultPreview;
+  return void 0;
+}
+function mapStepStatus(s) {
+  if (s === void 0) return "running";
+  return s;
+}
+function manualTraceEventsToComparableRun(events) {
+  const started = events.find((e) => e.event === "run_started");
+  if (!started || started.event !== "run_started") {
+    throw new Error("Invalid trace: missing run_started");
   }
-  const traceId = readStringField(span, ["traceId"]) ?? "trace-unknown";
-  const spanId = readStringField(span, ["spanId"]) ?? "span-unknown";
-  const parentSpanId = readStringField(span, ["parentSpanId"]);
-  const startedAt = readOpenInferenceTimestamp(
-    span,
-    ["startTimeUnixNano"],
-    []
-  );
-  const endedAt = readOpenInferenceTimestamp(span, ["endTimeUnixNano"], []);
-  const timestamp = startedAt ?? "1970-01-01T00:00:00.000Z";
-  if (startedAt === void 0) {
-    unsupportedFields.push(`${pathPrefix}.startTimeUnixNano`);
-    warnings.push({
-      code: "otlp_missing_start_time",
-      message: "OTLP span is missing a valid startTimeUnixNano; using Unix epoch.",
-      severity: "warning",
-      field: `${pathPrefix}.startTimeUnixNano`
+  const rs = started;
+  const runId = rs.runId;
+  const completedAll = events.filter((e) => e.event === "run_completed");
+  const lastCompleted = completedAll[completedAll.length - 1];
+  let runStatus;
+  if (lastCompleted === void 0) runStatus = "running";
+  else runStatus = lastCompleted.status;
+  const durationMs = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const steps = /* @__PURE__ */ new Map();
+  let order = 0;
+  for (const e of events) {
+    if (e.event !== "step_started") continue;
+    const s = e;
+    const meta = s.metadata ? { ...s.metadata } : void 0;
+    steps.set(s.stepId, {
+      id: s.stepId,
+      parentId: s.parentId,
+      name: s.name,
+      type: s.type,
+      order: order++,
+      timestamp: s.timestamp,
+      metadata: meta
     });
   }
-  const { kind, warnings: kindWarnings } = readOtlpKind(
-    parsedSpanAttributes.attributes,
-    pathPrefix
-  );
-  warnings.push(...kindWarnings);
-  const status = mapOtlpStatus(span.status);
-  const tokenUsage = readOtlpTokenUsage(parsedSpanAttributes.attributes);
-  const errorMessage = isRecord6(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
-  const event = {
-    schemaVersion: "0.2",
-    eventId: typeof parsedSpanAttributes.attributes["agent_inspect.event_id"] === "string" ? parsedSpanAttributes.attributes["agent_inspect.event_id"] : spanId,
-    runId: typeof parsedSpanAttributes.attributes["agent_inspect.run_id"] === "string" ? parsedSpanAttributes.attributes["agent_inspect.run_id"] : traceId,
-    kind,
-    name: readStringField(span, ["name"]) ?? spanId,
-    timestamp,
-    confidence: readOtlpConfidence(parsedSpanAttributes.attributes),
-    source: {
-      type: "otel",
-      name: context.scopeName ?? (typeof context.resourceAttributes["service.name"] === "string" ? context.resourceAttributes["service.name"] : "otlp-json"),
-      ...context.scopeVersion !== void 0 ? { version: context.scopeVersion } : {}
-    },
-    attributes,
-    trace: {
-      traceId,
-      spanId,
-      ...parentSpanId !== void 0 ? { parentSpanId } : {}
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const acc = steps.get(e.stepId);
+    if (!acc) continue;
+    acc.status = e.status;
+    acc.durationMs = e.durationMs;
+    if (e.error?.message) acc.errorMsg = e.error.message;
+    const extra = e;
+    if (extra.metadata !== void 0 && typeof extra.metadata === "object") {
+      acc.metadata = { ...acc.metadata ?? {}, ...extra.metadata };
     }
-  };
-  if (status !== void 0) {
-    event.status = status;
-  }
-  if (startedAt !== void 0) {
-    event.startedAt = startedAt;
-  }
-  if (endedAt !== void 0) {
-    event.endedAt = endedAt;
-  }
-  const durationMs = durationBetweenIso(startedAt, endedAt);
-  if (durationMs !== void 0) {
-    event.durationMs = durationMs;
   }
-  if (tokenUsage !== void 0) {
-    event.tokenUsage = tokenUsage;
-  }
-  if (status === "error") {
-    event.error = {
-      message: errorMessage !== void 0 && errorMessage.trim() !== "" ? errorMessage : "OTLP span error"
+  const nodes = /* @__PURE__ */ new Map();
+  for (const acc of steps.values()) {
+    let meta = acc.metadata ? { ...acc.metadata } : void 0;
+    if (acc.parentId !== void 0 && !steps.has(acc.parentId)) {
+      meta = { ...meta ?? {}, agent_inspect_diff_parent_missing: true };
+    }
+    const outputPreview = extractOutputPreview(meta);
+    const sc = {
+      id: acc.id,
+      name: acc.name,
+      type: acc.type,
+      status: mapStepStatus(acc.status),
+      durationMs: acc.durationMs,
+      error: acc.errorMsg,
+      metadata: meta && Object.keys(meta).length > 0 ? meta : void 0,
+      outputPreview,
+      children: []
     };
+    nodes.set(acc.id, sc);
   }
-  return {
-    event,
-    warnings,
-    unsupportedFields,
-    spanId,
-    ...parentSpanId !== void 0 ? { parentSpanId } : {}
+  const roots = [];
+  const sortByOrder = (a, b) => {
+    const oa = steps.get(a.id)?.order ?? 0;
+    const ob = steps.get(b.id)?.order ?? 0;
+    return oa - ob;
   };
-}
-function mapOtlpEventsToPersisted(document) {
-  const mapped = document.spans.map((span) => mapOtlpSpan(span));
-  const spanIdToEventId = new Map(
-    mapped.map((span) => [span.spanId, span.event.eventId])
-  );
-  for (const span of mapped) {
-    if (span.parentSpanId === void 0) continue;
-    span.event.parentId = spanIdToEventId.get(span.parentSpanId) ?? span.parentSpanId;
+  for (const acc of steps.values()) {
+    const node = nodes.get(acc.id);
+    if (acc.parentId !== void 0 && nodes.has(acc.parentId)) {
+      nodes.get(acc.parentId).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  roots.sort(sortByOrder);
+  for (const n of nodes.values()) {
+    n.children.sort(sortByOrder);
   }
   return {
-    events: mapped.map((span) => span.event),
-    warnings: mapped.flatMap((span) => span.warnings),
-    unsupportedFields: mapped.flatMap((span) => span.unsupportedFields)
+    runId,
+    name: rs.name,
+    status: runStatus,
+    durationMs,
+    steps: roots
   };
 }
-var otlpJsonReader = {
-  format: OTLP_READER_FORMAT,
-  name: "OTLP JSON",
-  async detect(input) {
-    const resolved = await resolveInput(input);
-    if (!resolved) return void 0;
-    let parsed;
-    try {
-      parsed = parseJsonDocument(resolved.content);
-    } catch {
-      return void 0;
+
+// packages/core/src/diff/engine.ts
+var DEFAULT_THRESHOLD_MS = 0;
+function pathSeg(step, index) {
+  return { index, name: step.name, stepId: step.id };
+}
+function buildPath(segments) {
+  return { path: [...segments] };
+}
+function pairSteps(left, right) {
+  const usedRight = /* @__PURE__ */ new Set();
+  const pairs = [];
+  for (let i = 0; i < left.length; i++) {
+    const L = left[i];
+    let R = right.find((r) => !usedRight.has(r.id) && r.id === L.id);
+    if (R === void 0 && i < right.length && !usedRight.has(right[i].id)) {
+      const cand = right[i];
+      if (cand.name === L.name && (cand.type ?? "") === (L.type ?? "")) {
+        R = cand;
+      }
     }
-    const document = extractOtlpDocument(parsed);
-    if (!document) return void 0;
-    return {
-      format: OTLP_READER_FORMAT,
-      confidence: document.confidence,
-      readerName: "OTLP JSON",
-      description: document.description,
-      warnings: attachSingleSourceFile(document.warnings, resolved)
-    };
-  },
-  async read(input) {
-    const resolved = await resolveInput(input);
-    if (!resolved) {
-      throw new TraceReadError(
-        "unsupported_format",
-        "OTLP JSON reader requires file, string, or buffer input."
+    if (R === void 0) {
+      R = right.find(
+        (r) => !usedRight.has(r.id) && r.name === L.name && (r.type ?? "") === (L.type ?? "")
       );
     }
-    let parsed;
-    try {
-      parsed = parseJsonDocument(resolved.content);
-    } catch {
-      throw new TraceReadError("unsupported_format", "OTLP JSON input is not valid JSON.", [
-        {
-          code: "otlp_invalid_json",
-          message: "OTLP JSON reader could not parse the input as JSON.",
-          severity: "error"
-        }
-      ]);
-    }
-    const document = extractOtlpDocument(parsed);
-    if (!document || document.spans.length === 0) {
-      throw new TraceReadError(
-        "unsupported_format",
-        "No valid OTLP spans found.",
-        attachSingleSourceFile(
-          document?.warnings ?? [
-            {
-              code: "otlp_no_valid_spans",
-              message: "OTLP JSON input did not contain valid spans.",
-              severity: "error"
-            }
-          ],
-          resolved
-        )
-      );
+    if (R !== void 0) {
+      usedRight.add(R.id);
+      pairs.push([L, R]);
+    } else {
+      pairs.push([L, void 0]);
     }
-    const mapped = mapOtlpEventsToPersisted(document);
-    const warnings = attachSingleSourceFile(
-      [...document.warnings, ...mapped.warnings],
-      resolved
-    );
-    const unsupportedFields = [
-      ...document.unsupportedFields,
-      ...mapped.unsupportedFields
-    ].sort((a, b) => a.localeCompare(b));
-    return {
-      format: OTLP_READER_FORMAT,
-      events: mapped.events,
-      runs: persistedInspectEventsToRunTrees(mapped.events, { skipInvalid: true }),
-      warnings,
-      unsupportedFields,
-      sourceFiles: resolved.sourceFiles
-    };
   }
-};
-var agentInspectJsonlReader = {
-  format: "agent-inspect-jsonl",
-  name: "AgentInspect JSONL",
-  async detect(input) {
-    const resolved = await resolveInput(input);
-    if (!resolved) return void 0;
-    const detected = detectJsonlFormat(resolved.content);
-    if (detected.validRows === 0 || detected.format === "empty") {
-      return void 0;
-    }
-    return {
-      format: "agent-inspect-jsonl",
-      confidence: 0.95,
-      readerName: "AgentInspect JSONL",
-      description: agentInspectFormatLabel(detected.format),
-      warnings: attachSingleSourceFile(detected.warnings, resolved)
-    };
-  },
-  async read(input) {
-    const resolved = await resolveInput(input);
-    if (!resolved) {
-      throw new Error("AgentInspect JSONL reader requires file, directory, string, or buffer input.");
+  for (const R of right) {
+    if (!usedRight.has(R.id)) {
+      pairs.push([void 0, R]);
     }
-    const parsed = parseTraceJsonl(resolved.content, { warnings: false });
-    if (parsed.sourceEventCount === 0) {
-      throw new Error("No valid AgentInspect JSONL events found.");
+  }
+  return pairs;
+}
+function compareLeafSteps(L, R, segments, opts, out) {
+  const path12 = buildPath(segments);
+  if (L.name !== R.name) {
+    out.push({
+      kind: "structure",
+      severity: "warning",
+      message: "Step name differs",
+      path: path12,
+      left: L.name,
+      right: R.name
+    });
+  }
+  if ((L.type ?? "") !== (R.type ?? "")) {
+    out.push({
+      kind: "step-type",
+      severity: "warning",
+      message: "Step type differs",
+      path: path12,
+      left: L.type,
+      right: R.type
+    });
+  }
+  if ((L.status ?? "") !== (R.status ?? "")) {
+    out.push({
+      kind: "step-status",
+      severity: "warning",
+      message: "Step status differs",
+      path: path12,
+      left: L.status,
+      right: R.status
+    });
+  }
+  const le = L.error ?? "";
+  const re = R.error ?? "";
+  if (le !== re) {
+    out.push({
+      kind: "error",
+      severity: "error",
+      message: "Step error message differs",
+      path: path12,
+      left: le || void 0,
+      right: re || void 0
+    });
+  }
+  if (!opts.ignoreDuration) {
+    const ld = L.durationMs;
+    const rd = R.durationMs;
+    const th = opts.durationThresholdMs;
+    let differs = false;
+    if (ld === void 0 && rd === void 0) differs = false;
+    else if (ld === void 0 || rd === void 0) differs = true;
+    else differs = Math.abs(ld - rd) > th;
+    if (differs) {
+      out.push({
+        kind: "duration",
+        severity: "info",
+        message: "Step duration differs",
+        path: path12,
+        left: ld,
+        right: rd
+      });
     }
-    const events = persistedEventsForParsedTrace(parsed);
-    return {
-      format: agentInspectFormatLabel(parsed.format),
-      events,
-      runs: persistedInspectEventsToRunTrees(events, { skipInvalid: true }),
-      warnings: parsed.format === "mixed" ? attachSingleSourceFile(
-        [
-          {
-            code: "mixed_agent_inspect_jsonl",
-            message: "Trace input mixes schemaVersion 0.1 and 0.2 rows; events were normalized for reading.",
-            severity: "warning"
-          }
-        ],
-        resolved
-      ) : [],
-      unsupportedFields: [],
-      sourceFiles: resolved.sourceFiles
-    };
   }
-};
-var DEFAULT_TRACE_READERS = [
-  agentInspectJsonlReader,
-  openInferenceJsonReader,
-  otlpJsonReader
-];
-async function detectTraceFormat(input, options = {}) {
-  const readers = options.readers ?? DEFAULT_TRACE_READERS;
-  if (options.format !== void 0) {
-    const reader = findReaderByFormat(options.format, readers);
-    if (!reader) {
-      return {
-        status: "unsupported",
-        candidates: [],
-        warnings: [
-          {
-            code: "unsupported_format",
-            message: `No trace reader is registered for format "${options.format}".`,
-            severity: "error"
-          }
-        ]
-      };
+  const lm = stableJson(L.metadata ?? {});
+  const rm = stableJson(R.metadata ?? {});
+  if (lm !== rm) {
+    out.push({
+      kind: "metadata",
+      severity: "info",
+      message: "Step metadata differs",
+      path: path12,
+      left: L.metadata,
+      right: R.metadata
+    });
+  }
+  const lo = stableJson(L.outputPreview ?? null);
+  const ro = stableJson(R.outputPreview ?? null);
+  if (lo !== ro) {
+    out.push({
+      kind: "output",
+      severity: "info",
+      message: "Output preview differs",
+      path: path12,
+      left: L.outputPreview,
+      right: R.outputPreview
+    });
+  }
+}
+function compareRecursive(L, R, segments, opts, out) {
+  compareLeafSteps(L, R, segments, opts, out);
+  const pairs = pairSteps(L.children, R.children);
+  let ci = 0;
+  for (const [lch, rch] of pairs) {
+    if (lch !== void 0 && rch !== void 0) {
+      compareRecursive(lch, rch, [...segments, pathSeg(lch, ci)], opts, out);
+    } else if (lch !== void 0) {
+      out.push({
+        kind: "step-removed",
+        severity: "warning",
+        message: `Step only in left run: ${lch.name}`,
+        path: buildPath([...segments, pathSeg(lch, ci)]),
+        left: lch.id,
+        right: void 0
+      });
+    } else if (rch !== void 0) {
+      out.push({
+        kind: "step-added",
+        severity: "warning",
+        message: `Step only in right run: ${rch.name}`,
+        path: buildPath([...segments, pathSeg(rch, ci)]),
+        left: void 0,
+        right: rch.id
+      });
     }
-    return {
-      status: "detected",
-      format: reader.format,
-      candidates: [
-        {
-          format: reader.format,
-          confidence: 1,
-          readerName: reader.name,
-          description: "Explicit format override"
-        }
-      ],
-      warnings: []
-    };
+    ci += 1;
   }
-  const candidates = [];
-  const warnings = [];
-  for (const reader of readers) {
-    try {
-      const candidate = await reader.detect(input);
-      if (candidate !== void 0) {
-        candidates.push(normalizeCandidate(reader, candidate));
-      }
-    } catch (error) {
-      if (error instanceof TraceReadError) {
-        warnings.push(...error.warnings);
-        continue;
-      }
-      warnings.push({
-        code: "reader_detect_failed",
-        message: error instanceof Error && error.message.trim() !== "" ? error.message : `Trace reader "${reader.format}" failed during detection.`,
-        severity: "warning"
+}
+function mergeDiffDefaults(options) {
+  return {
+    ignoreDuration: false,
+    durationThresholdMs: DEFAULT_THRESHOLD_MS,
+    focus: "all",
+    check: "all"
+  };
+}
+function kindMatchesFilter(kind, merged) {
+  return true;
+}
+function diffRuns(left, right, options) {
+  const merged = mergeDiffDefaults();
+  const opts = {
+    ignoreDuration: merged.ignoreDuration,
+    durationThresholdMs: merged.durationThresholdMs
+  };
+  const raw = [];
+  if ((left.status ?? "") !== (right.status ?? "")) {
+    raw.push({
+      kind: "run-status",
+      severity: "warning",
+      message: "Run completion status differs",
+      left: left.status,
+      right: right.status
+    });
+  }
+  {
+    const ld = left.durationMs;
+    const rd = right.durationMs;
+    const th = merged.durationThresholdMs;
+    let differs = false;
+    if (ld === void 0 && rd === void 0) differs = false;
+    else if (ld === void 0 || rd === void 0) differs = true;
+    else differs = Math.abs(ld - rd) > th;
+    if (differs) {
+      raw.push({
+        kind: "duration",
+        severity: "info",
+        message: "Run duration differs",
+        left: ld,
+        right: rd
       });
     }
   }
-  const sorted = sortCandidates(
-    candidates.filter((candidate) => candidate.confidence >= MIN_DETECTION_CONFIDENCE)
-  );
-  const candidateWarnings = collectWarnings(sorted);
-  const lowConfidenceWarnings = candidates.length > sorted.length ? [
-    {
-      code: "low_confidence_candidates",
-      message: `Ignored ${candidates.length - sorted.length} low-confidence format candidate(s).`,
-      severity: "info"
+  const pairs = pairSteps(left.steps, right.steps);
+  let idx = 0;
+  for (const [ls, rs] of pairs) {
+    if (ls !== void 0 && rs !== void 0) {
+      compareRecursive(ls, rs, [pathSeg(ls, idx)], opts, raw);
+      idx += 1;
+    } else if (ls !== void 0) {
+      raw.push({
+        kind: "step-removed",
+        severity: "warning",
+        message: `Step only in left run: ${ls.name}`,
+        path: buildPath([pathSeg(ls, idx)]),
+        left: ls.id,
+        right: void 0
+      });
+      idx += 1;
+    } else if (rs !== void 0) {
+      raw.push({
+        kind: "step-added",
+        severity: "warning",
+        message: `Step only in right run: ${rs.name}`,
+        path: buildPath([pathSeg(rs, idx)]),
+        left: void 0,
+        right: rs.id
+      });
+      idx += 1;
     }
-  ] : [];
-  const allWarnings = dedupeWarnings([
-    ...warnings,
-    ...candidateWarnings,
-    ...lowConfidenceWarnings
-  ]);
-  if (sorted.length === 0) {
-    return {
-      status: "unsupported",
-      candidates: [],
-      warnings: allWarnings
-    };
   }
-  const [best, second] = sorted;
-  if (second !== void 0 && best.confidence - second.confidence <= AMBIGUOUS_CONFIDENCE_DELTA) {
-    return {
-      status: "ambiguous",
-      candidates: sorted,
-      warnings: [
-        ...allWarnings,
-        {
-          code: "ambiguous_format_candidates",
-          message: `Top trace format candidates are within ${AMBIGUOUS_CONFIDENCE_DELTA} confidence.`,
-          severity: "warning"
-        }
-      ]
-    };
+  const differences = raw.filter((d) => kindMatchesFilter(d.kind));
+  let errors = 0;
+  let warnings = 0;
+  let info = 0;
+  for (const d of differences) {
+    if (d.severity === "error") errors += 1;
+    else if (d.severity === "warning") warnings += 1;
+    else info += 1;
   }
-  return {
-    status: "detected",
-    format: best.format,
-    candidates: sorted,
-    warnings: allWarnings
+  const firstVisible = differences[0];
+  const firstDivergence = firstVisible !== void 0 ? {
+    kind: "first-divergence",
+    severity: firstVisible.severity,
+    message: `First divergence: ${firstVisible.message}`,
+    path: firstVisible.path,
+    left: firstVisible.left,
+    right: firstVisible.right
+  } : void 0;
+  const summary = {
+    leftRunId: left.runId,
+    rightRunId: right.runId,
+    totalDifferences: differences.length,
+    errors,
+    warnings,
+    info,
+    firstDivergence
   };
+  return { summary, differences };
 }
-async function readTrace(input, options = {}) {
-  const readers = options.readers ?? DEFAULT_TRACE_READERS;
-  const detection = await detectTraceFormat(input, options);
-  if (detection.status === "unsupported" || detection.format === void 0) {
-    throw new TraceReadError(
-      "unsupported_format",
-      "No trace reader could detect the input format.",
-      detection.warnings
-    );
+
+// packages/core/src/exporters/markdown-exporter.ts
+function renderTreeAscii(nodes, indent = "") {
+  const lines = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    const last = i === nodes.length - 1;
+    const branch = last ? "\u2514\u2500 " : "\u251C\u2500 ";
+    const ev = n.event;
+    const status = ev.status ?? "?";
+    const dur = ev.durationMs !== void 0 && Number.isFinite(ev.durationMs) ? `${ev.durationMs}ms` : "-";
+    lines.push(`${indent}${branch}${escapeMarkdown(ev.name)} [${ev.kind}] ${status} (${dur})`);
+    const nextIndent = indent + (last ? "   " : "\u2502  ");
+    if (n.children.length > 0) {
+      const childStr = renderTreeAscii(n.children, nextIndent);
+      if (childStr.length > 0) lines.push(childStr);
+    }
   }
-  if (detection.status === "ambiguous") {
-    throw new TraceReadError(
-      "ambiguous_format",
-      "Multiple trace readers matched the input with equal confidence.",
-      detection.warnings
+  return lines.join("\n");
+}
+function exportMarkdown(tree, options) {
+  const warnings = [];
+  const includeMetadata = options?.includeMetadata ?? true;
+  const includeAttributes = options?.includeAttributes ?? false;
+  const includeErrors = options?.includeErrors ?? true;
+  const maxLen = options?.maxAttributeLength ?? 500;
+  const titleName = tree.name ?? tree.runId;
+  const lines = [];
+  lines.push(`# AgentInspect Run: ${escapeMarkdown(titleName)}`);
+  lines.push("");
+  lines.push("Generated locally by AgentInspect. Review for sensitive data before sharing.");
+  lines.push("");
+  if (includeMetadata) {
+    lines.push("## Summary");
+    lines.push("");
+    lines.push(`- **runId**: ${escapeMarkdown(tree.runId)}`);
+    if (tree.name !== void 0) lines.push(`- **name**: ${escapeMarkdown(tree.name)}`);
+    lines.push(`- **status**: ${escapeMarkdown(String(tree.status ?? "unknown"))}`);
+    lines.push(
+      `- **durationMs**: ${tree.durationMs !== void 0 ? escapeMarkdown(String(tree.durationMs)) : "-"}`
     );
-  }
-  const reader = findReaderByFormat(detection.format, readers);
-  if (!reader) {
-    throw new TraceReadError(
-      "unsupported_format",
-      `No trace reader is registered for format "${detection.format}".`,
-      detection.warnings
+    lines.push(
+      `- **startedAt**: ${tree.startedAt !== void 0 ? escapeMarkdown(String(tree.startedAt)) : "-"}`
+    );
+    lines.push(
+      `- **endedAt**: ${tree.endedAt !== void 0 ? escapeMarkdown(String(tree.endedAt)) : "-"}`
     );
+    lines.push(`- **totalEvents**: ${tree.metadata.totalEvents}`);
+    lines.push("");
+    lines.push("### Confidence breakdown");
+    lines.push("");
+    lines.push("| bucket | count |");
+    lines.push("| --- | --- |");
+    for (const k of Object.keys(tree.metadata.confidenceBreakdown).sort()) {
+      const key = k;
+      lines.push(
+        `| ${escapeMarkdown(key)} | ${tree.metadata.confidenceBreakdown[key]} |`
+      );
+    }
+    lines.push("");
+    lines.push("### Kind breakdown");
+    lines.push("");
+    lines.push("| kind | count |");
+    lines.push("| --- | --- |");
+    for (const k of Object.keys(tree.metadata.kinds).sort()) {
+      const key = k;
+      const c = tree.metadata.kinds[key];
+      if (c > 0) lines.push(`| ${escapeMarkdown(key)} | ${c} |`);
+    }
+    lines.push("");
   }
-  try {
-    const result = await reader.read(input, { format: detection.format });
-    return {
-      ...result,
-      format: result.format || detection.format,
-      warnings: [...detection.warnings, ...result.warnings]
-    };
-  } catch (error) {
-    if (error instanceof TraceReadError) {
-      throw new TraceReadError(
-        error.code,
-        error.message,
-        dedupeWarnings([...detection.warnings, ...error.warnings])
+  lines.push("## Execution tree");
+  lines.push("");
+  lines.push("```text");
+  lines.push(
+    tree.children.length > 0 ? renderTreeAscii(tree.children) : "(no steps)"
+  );
+  lines.push("```");
+  lines.push("");
+  const flat = flattenTree(tree);
+  const errors = flat.filter((n) => n.event.status === "error");
+  if (includeErrors && errors.length > 0) {
+    lines.push("## Errors");
+    lines.push("");
+    for (const n of errors) {
+      const msg = n.event.attributes && typeof n.event.attributes.error === "object" ? safeString(
+        n.event.attributes.error.message,
+        maxLen
+      ) : "";
+      lines.push(
+        `- **${escapeMarkdown(n.event.name)}** (${escapeMarkdown(n.event.eventId)}): ${escapeMarkdown(msg || "error")}`
       );
     }
-    throw new TraceReadError(
-      "reader_failed",
-      error instanceof Error && error.message.trim() !== "" ? error.message : `Trace reader "${reader.format}" failed.`,
-      detection.warnings
+    lines.push("");
+  }
+  if (includeAttributes) {
+    lines.push("## Attributes (bounded)");
+    lines.push("");
+    for (const n of flat) {
+      if (!n.event.attributes || Object.keys(n.event.attributes).length === 0) continue;
+      const compact = compactAttributes3(n.event.attributes, {
+        maxLength: maxLen});
+      lines.push(`### ${escapeMarkdown(n.event.name)}`);
+      lines.push("");
+      lines.push("```json");
+      lines.push(stableJson(compact, true));
+      lines.push("```");
+      lines.push("");
+    }
+    warnings.push(
+      "Attributes may still contain sensitive data; review exports before sharing."
     );
   }
-}
-function openTrace(input, options = {}) {
-  return readTrace(input, options);
+  return {
+    format: "markdown",
+    content: lines.join("\n"),
+    contentType: "text/markdown",
+    fileExtension: ".md",
+    warnings
+  };
 }
 
 // packages/mcp-server/src/tools.ts