@agent-inspect/mcp-server 2.6.0

package/dist/index.cjs

@@ -0,0 +1,4450 @@
+'use strict';
+
+var readline = require('readline');
+var path = require('path');
+var async_hooks = require('async_hooks');
+require('crypto');
+var promises = require('fs/promises');
+var os = require('os');
+require('nanoid');
+require('chalk');
+require('fs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var readline__default = /*#__PURE__*/_interopDefault(readline);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var os__default = /*#__PURE__*/_interopDefault(os);
+
+// packages/mcp-server/src/index.ts
+
+// packages/core/src/correlation-metadata.ts
+var TRACE_CORRELATION_KEYS = [
+  "correlationId",
+  "requestId",
+  "decisionId",
+  "groupId"
+];
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function extractCorrelationMetadata(record) {
+  if (!record) {
+    return void 0;
+  }
+  const out = {};
+  let found = false;
+  for (const key of TRACE_CORRELATION_KEYS) {
+    const value = record[key];
+    if (isNonEmptyString(value)) {
+      out[key] = value;
+      found = true;
+    }
+  }
+  return found ? out : void 0;
+}
+
+// packages/core/src/types.ts
+var STEP_TYPES = [
+  "run",
+  "llm",
+  "tool",
+  "decision",
+  "logic",
+  "state",
+  "custom"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStepType(value) {
+  return typeof value === "string" && STEP_TYPES.includes(value);
+}
+function isTraceEvent(value) {
+  if (!isRecord(value)) return false;
+  if (value.schemaVersion !== "0.1") return false;
+  if (typeof value.timestamp !== "number") return false;
+  if (typeof value.event !== "string") return false;
+  switch (value.event) {
+    case "run_started": {
+      return typeof value.runId === "string" && typeof value.name === "string" && typeof value.startTime === "number";
+    }
+    case "run_completed": {
+      return typeof value.runId === "string" && (value.status === "success" || value.status === "error") && typeof value.endTime === "number" && typeof value.durationMs === "number";
+    }
+    case "step_started": {
+      return typeof value.runId === "string" && typeof value.stepId === "string" && typeof value.name === "string" && isStepType(value.type) && typeof value.startTime === "number";
+    }
+    case "step_completed": {
+      return typeof value.runId === "string" && typeof value.stepId === "string" && (value.status === "success" || value.status === "error") && typeof value.endTime === "number" && typeof value.durationMs === "number";
+    }
+    default:
+      return false;
+  }
+}
+
+// packages/core/src/types/persisted-inspect-event.ts
+var INSPECT_KINDS = [
+  "RUN",
+  "AGENT",
+  "LLM",
+  "TOOL",
+  "CHAIN",
+  "RETRIEVER",
+  "DECISION",
+  "RESULT",
+  "ERROR",
+  "LOGIC",
+  "LOG"
+];
+var ATTRIBUTION_CONFIDENCES = [
+  "explicit",
+  "correlated",
+  "heuristic",
+  "unknown"
+];
+var PERSISTED_EVENT_SOURCE_TYPES = [
+  "manual",
+  "json-log",
+  "log4js",
+  "adapter",
+  "ai-sdk",
+  "otel"
+];
+var PERSISTED_EVENT_STATUSES = [
+  "running",
+  "ok",
+  "error",
+  "unknown"
+];
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isOptionalString(value) {
+  return value === void 0 || isString(value);
+}
+function isNonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isOptionalNonNegativeNumber(value) {
+  return value === void 0 || isNonNegativeNumber(value);
+}
+function isInspectKind(value) {
+  return typeof value === "string" && INSPECT_KINDS.includes(value);
+}
+function isAttributionConfidence(value) {
+  return typeof value === "string" && ATTRIBUTION_CONFIDENCES.includes(value);
+}
+function isPersistedEventSourceType(value) {
+  return typeof value === "string" && PERSISTED_EVENT_SOURCE_TYPES.includes(value);
+}
+function isPersistedEventStatus(value) {
+  return typeof value === "string" && PERSISTED_EVENT_STATUSES.includes(value);
+}
+function isPersistedEventSource(value) {
+  if (!isRecord2(value)) return false;
+  if (!isPersistedEventSourceType(value.type)) return false;
+  if (!isOptionalString(value.name)) return false;
+  if (!isOptionalString(value.version)) return false;
+  return true;
+}
+function isPersistedInspectError(value) {
+  if (!isRecord2(value)) return false;
+  if (!isNonEmptyString2(value.message)) return false;
+  if (!isOptionalString(value.name)) return false;
+  if (!isOptionalString(value.code)) return false;
+  return true;
+}
+function isPersistedTokenUsage(value) {
+  if (!isRecord2(value)) return false;
+  if (!isOptionalNonNegativeNumber(value.input)) return false;
+  if (!isOptionalNonNegativeNumber(value.output)) return false;
+  if (!isOptionalNonNegativeNumber(value.total)) return false;
+  if (!isOptionalNonNegativeNumber(value.cached)) return false;
+  return true;
+}
+function isPersistedTraceContext(value) {
+  if (!isRecord2(value)) return false;
+  if (!isOptionalString(value.traceId)) return false;
+  if (!isOptionalString(value.spanId)) return false;
+  if (!isOptionalString(value.parentSpanId)) return false;
+  return true;
+}
+function isPersistedInspectEvent(value) {
+  if (!isRecord2(value)) return false;
+  if (value.schemaVersion !== "0.2" && value.schemaVersion !== "1.0") {
+    return false;
+  }
+  if (!isNonEmptyString2(value.eventId)) return false;
+  if (!isNonEmptyString2(value.runId)) return false;
+  if (!isInspectKind(value.kind)) return false;
+  if (!isNonEmptyString2(value.name)) return false;
+  if (!isNonEmptyString2(value.timestamp)) return false;
+  if (!isAttributionConfidence(value.confidence)) return false;
+  if (!isPersistedEventSource(value.source)) return false;
+  if (value.parentId !== void 0 && !isNonEmptyString2(value.parentId)) {
+    return false;
+  }
+  if (value.status !== void 0 && !isPersistedEventStatus(value.status)) {
+    return false;
+  }
+  if (!isOptionalString(value.startedAt)) return false;
+  if (!isOptionalString(value.endedAt)) return false;
+  if (value.durationMs !== void 0 && !isNonNegativeNumber(value.durationMs)) {
+    return false;
+  }
+  if (value.attributes !== void 0 && !isRecord2(value.attributes)) {
+    return false;
+  }
+  if (value.error !== void 0 && !isPersistedInspectError(value.error)) {
+    return false;
+  }
+  if (value.tokenUsage !== void 0 && !isPersistedTokenUsage(value.tokenUsage)) {
+    return false;
+  }
+  if (value.trace !== void 0 && !isPersistedTraceContext(value.trace)) {
+    return false;
+  }
+  return true;
+}
+
+// packages/core/src/persisted/to-trace-event.ts
+function parseIsoToMs(iso) {
+  const parsed = Date.parse(iso);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function mapInspectKindToStepType(kind) {
+  switch (kind) {
+    case "LLM":
+      return "llm";
+    case "TOOL":
+      return "tool";
+    case "DECISION":
+      return "decision";
+    case "RUN":
+      return "run";
+    default:
+      return "logic";
+  }
+}
+function mapPersistedStatusToStepStatus(status) {
+  switch (status) {
+    case "ok":
+      return "success";
+    case "error":
+      return "error";
+    case "running":
+      return "running";
+    default:
+      return void 0;
+  }
+}
+function mapPersistedStatusToRunStatus(status) {
+  switch (status) {
+    case "ok":
+      return "success";
+    case "error":
+      return "error";
+    case "running":
+      return "running";
+    default:
+      return void 0;
+  }
+}
+function mapPersistedError(error, attributes) {
+  if (!error?.message) return void 0;
+  const out = { message: error.message };
+  const stack = typeof attributes?.errorStack === "string" && attributes.errorStack.length > 0 ? attributes.errorStack : void 0;
+  if (stack) {
+    out.stack = stack;
+  }
+  return out;
+}
+function mapTokenUsageToMetadata(tokenUsage, attributes) {
+  const metadata = {};
+  if (attributes?.metadata && typeof attributes.metadata === "object") {
+    Object.assign(metadata, attributes.metadata);
+  }
+  if (tokenUsage) {
+    metadata.tokens = {
+      ...tokenUsage.input !== void 0 ? { input: tokenUsage.input } : {},
+      ...tokenUsage.output !== void 0 ? { output: tokenUsage.output } : {},
+      ...tokenUsage.total !== void 0 ? { total: tokenUsage.total } : {},
+      ...tokenUsage.cached !== void 0 ? { cached: tokenUsage.cached } : {}
+    };
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function pickRunMetadata(attributes) {
+  if (!attributes) return void 0;
+  const metadata = attributes.metadata && typeof attributes.metadata === "object" ? { ...attributes.metadata } : {};
+  for (const key of [
+    "correlationId",
+    "requestId",
+    "decisionId",
+    "groupId"
+  ]) {
+    const value = attributes[key];
+    if (typeof value === "string" && value.trim() !== "") {
+      metadata[key] = value;
+    }
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function resolveStepId(event) {
+  const attrs = event.attributes;
+  if (attrs && typeof attrs.stepId === "string" && attrs.stepId.trim() !== "") {
+    return attrs.stepId;
+  }
+  return event.eventId;
+}
+function resolveStepType(event) {
+  const attrs = event.attributes;
+  if (attrs && typeof attrs.stepType === "string") {
+    const t = attrs.stepType;
+    if (t === "run" || t === "llm" || t === "tool" || t === "decision" || t === "logic" || t === "state" || t === "custom") {
+      return t;
+    }
+  }
+  return mapInspectKindToStepType(event.kind);
+}
+function resolveTimes(event) {
+  const timestamp = parseIsoToMs(event.timestamp);
+  const startTime = event.startedAt !== void 0 ? parseIsoToMs(event.startedAt) : timestamp;
+  let endTime = event.endedAt !== void 0 ? parseIsoToMs(event.endedAt) : timestamp;
+  if (event.durationMs !== void 0 && Number.isFinite(event.durationMs) && event.durationMs >= 0 && event.endedAt === void 0) {
+    endTime = startTime + event.durationMs;
+  }
+  return { timestamp, startTime, endTime };
+}
+function fromLegacyRunStarted(event) {
+  const { timestamp, startTime } = resolveTimes(event);
+  const out = {
+    schemaVersion: "0.1",
+    event: "run_started",
+    timestamp,
+    runId: event.runId,
+    name: event.name,
+    startTime
+  };
+  const metadata = pickRunMetadata(event.attributes);
+  if (metadata) out.metadata = metadata;
+  return out;
+}
+function fromLegacyRunCompleted(event) {
+  const { timestamp, endTime } = resolveTimes(event);
+  const status = mapPersistedStatusToRunStatus(event.status) ?? "success";
+  const out = {
+    schemaVersion: "0.1",
+    event: "run_completed",
+    timestamp,
+    runId: event.runId,
+    status: status === "running" ? "success" : status,
+    endTime,
+    durationMs: event.durationMs ?? Math.max(0, endTime - timestamp)
+  };
+  const error = mapPersistedError(event.error, event.attributes);
+  if (error) out.error = error;
+  return out;
+}
+function fromLegacyStepStarted(event) {
+  const { timestamp, startTime } = resolveTimes(event);
+  const out = {
+    schemaVersion: "0.1",
+    event: "step_started",
+    timestamp,
+    runId: event.runId,
+    stepId: resolveStepId(event),
+    name: event.name,
+    type: resolveStepType(event),
+    startTime
+  };
+  if (event.parentId !== void 0) out.parentId = event.parentId;
+  const metadata = mapTokenUsageToMetadata(event.tokenUsage, event.attributes);
+  if (metadata) out.metadata = metadata;
+  return out;
+}
+function fromLegacyStepCompleted(event) {
+  const { timestamp, endTime } = resolveTimes(event);
+  const status = mapPersistedStatusToStepStatus(event.status) ?? "success";
+  const out = {
+    schemaVersion: "0.1",
+    event: "step_completed",
+    timestamp,
+    runId: event.runId,
+    stepId: resolveStepId(event),
+    status: status === "running" ? "success" : status,
+    endTime,
+    durationMs: event.durationMs ?? Math.max(0, endTime - timestamp)
+  };
+  const error = mapPersistedError(event.error, event.attributes);
+  if (error) out.error = error;
+  return out;
+}
+function fromNativeRun(event) {
+  const { timestamp, startTime, endTime } = resolveTimes(event);
+  const runStatus = mapPersistedStatusToRunStatus(event.status);
+  const out = [];
+  if (runStatus === "running" || event.startedAt !== void 0) {
+    const started = {
+      schemaVersion: "0.1",
+      event: "run_started",
+      timestamp,
+      runId: event.runId,
+      name: event.name,
+      startTime
+    };
+    const metadata = pickRunMetadata(event.attributes);
+    if (metadata) started.metadata = metadata;
+    out.push(started);
+  }
+  if (runStatus === "success" || runStatus === "error" || event.endedAt !== void 0) {
+    const completed = {
+      schemaVersion: "0.1",
+      event: "run_completed",
+      timestamp,
+      runId: event.runId,
+      status: runStatus === "error" ? "error" : "success",
+      endTime,
+      durationMs: event.durationMs ?? Math.max(0, endTime - startTime)
+    };
+    const error = mapPersistedError(event.error, event.attributes);
+    if (error) completed.error = error;
+    out.push(completed);
+  }
+  if (out.length === 0) {
+    out.push(fromLegacyRunStarted(event));
+  }
+  return out;
+}
+function fromNativeStep(event) {
+  const { timestamp, startTime, endTime } = resolveTimes(event);
+  const stepStatus = mapPersistedStatusToStepStatus(event.status);
+  const stepId = resolveStepId(event);
+  const out = [];
+  const shouldEmitStarted = stepStatus === "running" || event.startedAt !== void 0 || stepStatus === "success" || stepStatus === "error";
+  if (shouldEmitStarted) {
+    const started = {
+      schemaVersion: "0.1",
+      event: "step_started",
+      timestamp,
+      runId: event.runId,
+      stepId,
+      name: event.name,
+      type: resolveStepType(event),
+      startTime
+    };
+    if (event.parentId !== void 0) started.parentId = event.parentId;
+    const metadata = mapTokenUsageToMetadata(event.tokenUsage, event.attributes);
+    if (metadata) started.metadata = metadata;
+    out.push(started);
+  }
+  if (stepStatus === "success" || stepStatus === "error" || event.endedAt !== void 0 || event.durationMs !== void 0) {
+    const completed = {
+      schemaVersion: "0.1",
+      event: "step_completed",
+      timestamp,
+      runId: event.runId,
+      stepId,
+      status: stepStatus === "error" ? "error" : "success",
+      endTime,
+      durationMs: event.durationMs ?? Math.max(0, endTime - startTime)
+    };
+    const error = mapPersistedError(event.error, event.attributes);
+    if (error) completed.error = error;
+    out.push(completed);
+  }
+  if (out.length === 0) {
+    out.push(fromLegacyStepStarted(event));
+  }
+  return out;
+}
+function persistedInspectEventToTraceEvents(event) {
+  if (!isPersistedInspectEvent(event)) {
+    throw new Error("Invalid PersistedInspectEvent: failed isPersistedInspectEvent");
+  }
+  const legacyEvent = event.attributes?.legacyEvent;
+  if (legacyEvent === "run_started") return [fromLegacyRunStarted(event)];
+  if (legacyEvent === "run_completed") return [fromLegacyRunCompleted(event)];
+  if (legacyEvent === "step_started") return [fromLegacyStepStarted(event)];
+  if (legacyEvent === "step_completed") return [fromLegacyStepCompleted(event)];
+  if (event.kind === "RUN") {
+    return fromNativeRun(event);
+  }
+  return fromNativeStep(event);
+}
+function persistedInspectEventsToTraceEvents(events, options) {
+  const out = [];
+  events.forEach((event, index) => {
+    const rows = persistedInspectEventToTraceEvents(event);
+    if (rows.length === 0 && options?.eventIndex !== void 0) ;
+    out.push(...rows);
+  });
+  return out;
+}
+
+// packages/core/src/utils/duration.ts
+function parseDuration(duration) {
+  const raw = typeof duration === "string" ? duration.trim() : "";
+  const match = raw.match(/^(\d+)(ms|[smhd])$/);
+  if (!match) {
+    throw new Error(
+      `Invalid duration format: ${duration}. Use a positive integer followed by ms, s, m, h, or d (e.g. 500ms, 30s, 5m, 2h, 7d).`
+    );
+  }
+  const amount = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  if (!Number.isFinite(amount) || amount <= 0) {
+    throw new Error(
+      `Invalid duration amount: ${duration}. Amount must be a positive integer.`
+    );
+  }
+  switch (unit) {
+    case "ms":
+      return amount;
+    case "s":
+      return amount * 1e3;
+    case "m":
+      return amount * 60 * 1e3;
+    case "h":
+      return amount * 60 * 60 * 1e3;
+    case "d":
+      return amount * 24 * 60 * 60 * 1e3;
+    default: {
+      throw new Error(`Unknown duration unit: ${unit}`);
+    }
+  }
+}
+
+// packages/core/src/utils.ts
+var DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
+var RUNS_DIR_NAME = "runs";
+var FALLBACK_TRACE_DIR = path__default.default.join(
+  os__default.default.tmpdir(),
+  "agent-inspect",
+  RUNS_DIR_NAME
+);
+function getDefaultTraceDir() {
+  const envDir = process.env.AGENT_INSPECT_TRACE_DIR;
+  if (typeof envDir === "string" && envDir.trim() !== "") {
+    return envDir.trim();
+  }
+  try {
+    const home = os__default.default.homedir();
+    if (typeof home !== "string" || home.trim() === "") {
+      return FALLBACK_TRACE_DIR;
+    }
+    return path__default.default.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
+  } catch {
+    return FALLBACK_TRACE_DIR;
+  }
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    const out = { message: error.message };
+    if (typeof error.stack === "string" && error.stack.length > 0) {
+      out.stack = error.stack;
+    }
+    return out;
+  }
+  if (typeof error === "string") {
+    return { message: error };
+  }
+  if (error === null) {
+    return { message: "Unknown error: null" };
+  }
+  if (error === void 0) {
+    return { message: "Unknown error: undefined" };
+  }
+  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+    return { message: String(error) };
+  }
+  if (typeof error === "object") {
+    try {
+      return { message: JSON.stringify(error) };
+    } catch {
+      return { message: "Unknown error" };
+    }
+  }
+  return { message: "Unknown error" };
+}
+function warn(message, error) {
+  const base = `[AgentInspect] ${message}`;
+  if (error === void 0) {
+    console.warn(base);
+    return;
+  }
+  console.warn(`${base}: ${formatError(error).message}`);
+}
+
+// packages/core/src/read-trace.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function detectLineFormat(parsed) {
+  if (!isRecord3(parsed)) return "unknown";
+  if (parsed.schemaVersion === "0.1") return "0.1";
+  if (parsed.schemaVersion === "0.2") return "0.2";
+  if (parsed.schemaVersion === "1.0") return "1.0";
+  return "unknown";
+}
+function parseTraceJsonl(raw, options = {}) {
+  const validate = options.validate ?? isTraceEvent;
+  const emitWarning = (message) => {
+    if (options.warnings !== false) warn(message);
+  };
+  const persisted = [];
+  const traceEvents = [];
+  const rows = [];
+  let sourceEventCount = 0;
+  let saw01 = false;
+  let saw02 = false;
+  let saw10 = false;
+  let lineNumber = 0;
+  for (const line of raw.split(/\r?\n/)) {
+    lineNumber += 1;
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      emitWarning("Skipped invalid JSON line in trace file");
+      continue;
+    }
+    const format2 = detectLineFormat(parsed);
+    if (format2 === "0.1") {
+      saw01 = true;
+      if (validate(parsed)) {
+        sourceEventCount += 1;
+        traceEvents.push(parsed);
+        rows.push({ format: "0.1", event: parsed, sourceLine: lineNumber });
+      } else {
+        emitWarning("Skipped invalid trace event line in trace file");
+      }
+      continue;
+    }
+    if (format2 === "0.2" || format2 === "1.0") {
+      if (format2 === "0.2") saw02 = true;
+      else saw10 = true;
+      if (isPersistedInspectEvent(parsed)) {
+        sourceEventCount += 1;
+        persisted.push(parsed);
+        rows.push({ format: format2, event: parsed, sourceLine: lineNumber });
+        traceEvents.push(...persistedInspectEventToTraceEvents(parsed));
+      } else {
+        emitWarning("Skipped invalid persisted inspect event line in trace file");
+      }
+      continue;
+    }
+    emitWarning("Skipped trace line with unknown schemaVersion");
+  }
+  const seenFormats = [saw01, saw02, saw10].filter(Boolean).length;
+  if (seenFormats > 1) {
+    emitWarning(
+      "Trace file mixes AgentInspect schemaVersion rows; normalizing all rows"
+    );
+  }
+  let format = "empty";
+  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, sourceEventCount, events: traceEvents, persisted, rows };
+}
+
+// packages/core/src/storage.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function optionalErrorInfo(value) {
+  if (value === void 0) return true;
+  if (!isRecord4(value)) return false;
+  if (typeof value.message !== "string") return false;
+  if ("stack" in value && value.stack !== void 0) {
+    if (typeof value.stack !== "string") return false;
+  }
+  return true;
+}
+function validateEvent(event) {
+  if (!isRecord4(event)) return false;
+  if (event.schemaVersion !== "0.1") return false;
+  if (!finiteNumber(event.timestamp)) return false;
+  if (typeof event.event !== "string") return false;
+  switch (event.event) {
+    case "run_started": {
+      if (!nonEmptyString(event.runId) || !nonEmptyString(event.name) || !finiteNumber(event.startTime)) {
+        return false;
+      }
+      if (event.metadata !== void 0 && !isRecord4(event.metadata)) {
+        return false;
+      }
+      return true;
+    }
+    case "run_completed": {
+      return nonEmptyString(event.runId) && (event.status === "success" || event.status === "error") && finiteNumber(event.endTime) && finiteNumber(event.durationMs) && optionalErrorInfo(event.error);
+    }
+    case "step_started": {
+      if (!nonEmptyString(event.runId) || !nonEmptyString(event.stepId) || !nonEmptyString(event.name) || !isStepType(event.type) || !finiteNumber(event.startTime)) {
+        return false;
+      }
+      if (event.parentId !== void 0 && typeof event.parentId !== "string") {
+        return false;
+      }
+      if (event.metadata !== void 0 && !isRecord4(event.metadata)) {
+        return false;
+      }
+      return true;
+    }
+    case "step_completed": {
+      return nonEmptyString(event.runId) && nonEmptyString(event.stepId) && (event.status === "success" || event.status === "error") && finiteNumber(event.endTime) && finiteNumber(event.durationMs) && optionalErrorInfo(event.error);
+    }
+    default:
+      return false;
+  }
+}
+async function readTraceEventsFromFile(filePath) {
+  try {
+    const raw = await promises.readFile(filePath, "utf-8");
+    return parseTraceJsonl(raw, { validate: validateEvent }).events;
+  } catch (e) {
+    if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+      return [];
+    }
+    warn("Failed to read trace events from file", e);
+    return [];
+  }
+}
+
+// packages/core/src/context.ts
+new async_hooks.AsyncLocalStorage();
+function resolveTraceDir(options = {}) {
+  if (typeof options.dir === "string" && options.dir.trim() !== "") {
+    return options.dir.trim();
+  }
+  const envDir = process.env.AGENT_INSPECT_TRACE_DIR;
+  if (typeof envDir === "string" && envDir.trim() !== "") {
+    return envDir.trim();
+  }
+  return getDefaultTraceDir();
+}
+var TraceDirectory = class {
+  #dir;
+  constructor(options = {}) {
+    this.#dir = resolveTraceDir(options);
+  }
+  getPath(filename) {
+    return filename ? path__default.default.join(this.#dir, filename) : this.#dir;
+  }
+  async list() {
+    try {
+      const files = await promises.readdir(this.#dir);
+      return files.filter((f) => f.endsWith(".jsonl"));
+    } catch (e) {
+      if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+        return [];
+      }
+      throw e;
+    }
+  }
+  async getFileStats(filename) {
+    return await promises.stat(this.getPath(filename));
+  }
+};
+function isFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function parseIsoToMs2(value) {
+  if (value === void 0) return void 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+async function extractMetadata(filePath, _quickScan) {
+  const stats = await promises.stat(filePath);
+  let runIdFromFile = path__default.default.basename(filePath);
+  if (runIdFromFile.endsWith(".jsonl")) {
+    runIdFromFile = runIdFromFile.slice(0, -".jsonl".length);
+  }
+  const raw = await promises.readFile(filePath, "utf-8");
+  const parsedTrace = parseTraceJsonl(raw, { warnings: false });
+  let runId;
+  let name;
+  let startedAt;
+  let endedAt;
+  let explicitDurationMs;
+  let hasRunStarted = false;
+  let hasRunCompleted = false;
+  let runCompletedStatus;
+  let anyStepError = false;
+  const anyKnownEvent = parsedTrace.sourceEventCount > 0;
+  let persistedStatus;
+  const persistedRun = parsedTrace.persisted.find(
+    (event) => event.kind === "RUN"
+  );
+  if (persistedRun) {
+    runId = persistedRun.runId;
+    if (persistedRun.name.trim() !== "") {
+      name = persistedRun.name;
+    }
+    startedAt = parseIsoToMs2(persistedRun.startedAt) ?? parseIsoToMs2(persistedRun.timestamp);
+    endedAt = parseIsoToMs2(persistedRun.endedAt);
+    if (isFiniteNumber(persistedRun.durationMs)) {
+      explicitDurationMs = persistedRun.durationMs;
+      if (endedAt === void 0 && startedAt !== void 0) {
+        endedAt = startedAt + persistedRun.durationMs;
+      }
+    }
+    if (persistedRun.status === "ok") persistedStatus = "success";
+    else if (persistedRun.status === "error") persistedStatus = "error";
+    else if (persistedRun.status === "running") persistedStatus = "running";
+    else if (persistedRun.status === "unknown") persistedStatus = "unknown";
+  } else {
+    runId = parsedTrace.persisted[0]?.runId;
+  }
+  for (const e of parsedTrace.events) {
+    if (runId === void 0 && typeof e.runId === "string") {
+      runId = e.runId;
+    }
+    if (e.event === "run_started") {
+      hasRunStarted = true;
+      const rs = e;
+      if (typeof rs.name === "string" && rs.name.trim() !== "") {
+        name = rs.name;
+      }
+      if (isFiniteNumber(rs.startTime)) {
+        startedAt = rs.startTime;
+      } else if (isFiniteNumber(rs.timestamp)) {
+        startedAt = rs.timestamp;
+      }
+    }
+    if (e.event === "run_completed") {
+      hasRunCompleted = true;
+      const rc = e;
+      runCompletedStatus = rc.status;
+      if (isFiniteNumber(rc.endTime)) endedAt = rc.endTime;
+      else if (isFiniteNumber(rc.timestamp)) endedAt = rc.timestamp;
+      if (isFiniteNumber(rc.durationMs)) explicitDurationMs = rc.durationMs;
+    }
+    if (e.event === "step_completed") {
+      const sc = e;
+      if (sc.status === "error") {
+        anyStepError = true;
+      }
+    }
+  }
+  const resolvedRunId = runId ?? runIdFromFile;
+  let status = "unknown";
+  if (hasRunCompleted && (runCompletedStatus === "success" || runCompletedStatus === "error")) {
+    status = runCompletedStatus;
+  } else if (anyStepError) {
+    status = "error";
+  } else if (persistedStatus !== void 0) {
+    status = persistedStatus;
+  } else if (hasRunStarted && !hasRunCompleted) {
+    status = "running";
+  } else if (anyKnownEvent) {
+    status = "unknown";
+  } else {
+    status = "unknown";
+  }
+  const durationMs = explicitDurationMs ?? (startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt ? endedAt - startedAt : void 0);
+  return {
+    runId: resolvedRunId,
+    name,
+    status,
+    startedAt,
+    endedAt,
+    durationMs,
+    eventCount: parsedTrace.sourceEventCount,
+    filePath,
+    fileSize: stats.size,
+    createdAt: stats.birthtime
+  };
+}
+
+// packages/core/src/trace-filter.ts
+function toLower(s) {
+  return typeof s === "string" ? s.toLowerCase() : "";
+}
+function filterTraces(traces, options) {
+  const input = [...traces];
+  let out = input.filter((t) => {
+    if (options.status && t.status !== options.status) return false;
+    if (options.name) {
+      const q = options.name.toLowerCase();
+      const hay = `${toLower(t.name)} ${toLower(t.runId)}`;
+      if (!hay.includes(q)) return false;
+    }
+    if (options.since) {
+      const windowMs = parseDuration(options.since);
+      const cutoff = Date.now() - windowMs;
+      const started = typeof t.startedAt === "number" ? t.startedAt : void 0;
+      const basis = started ?? t.createdAt.getTime();
+      if (!Number.isFinite(basis) || basis < cutoff) return false;
+    }
+    return true;
+  });
+  out.sort((a, b) => {
+    const aTime = (typeof a.startedAt === "number" ? a.startedAt : void 0) ?? a.createdAt.getTime();
+    const bTime = (typeof b.startedAt === "number" ? b.startedAt : void 0) ?? b.createdAt.getTime();
+    return bTime - aTime;
+  });
+  if (typeof options.limit === "number" && Number.isFinite(options.limit)) {
+    const n = Math.max(0, Math.floor(options.limit));
+    out = out.slice(0, n);
+  }
+  return out;
+}
+
+// packages/core/src/timeline.ts
+function finite(n) {
+  return typeof n === "number" && Number.isFinite(n);
+}
+function pickStreamingMeta(metadata) {
+  if (!metadata || typeof metadata !== "object") return void 0;
+  const chunkCount = metadata.chunkCount;
+  const streamDurationMs = metadata.streamDurationMs;
+  const streamedCharCount = metadata.streamedCharCount;
+  if (!finite(chunkCount) && !finite(streamDurationMs) && !finite(streamedCharCount)) {
+    return void 0;
+  }
+  return {
+    ...finite(chunkCount) ? { chunkCount } : {},
+    ...finite(streamDurationMs) ? { streamDurationMs } : {},
+    ...finite(streamedCharCount) ? { streamedCharCount } : {}
+  };
+}
+function pickCorrelation(metadata) {
+  if (!metadata || typeof metadata !== "object") return void 0;
+  const out = {};
+  for (const key of [
+    "correlationId",
+    "requestId",
+    "decisionId",
+    "groupId"
+  ]) {
+    const v = metadata[key];
+    if (typeof v === "string" && v.trim() !== "") {
+      out[key] = v;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function buildRunTimeline(events, options = {}) {
+  const started = events.find(
+    (e) => e.event === "run_started"
+  );
+  const completed = events.filter(
+    (e) => e.event === "run_completed"
+  );
+  const lastCompleted = completed[completed.length - 1];
+  const runId = started?.runId ?? events.find((e) => typeof e.runId === "string")?.runId ?? "unknown-run";
+  const runStart = started && finite(started.startTime) ? started.startTime : started && finite(started.timestamp) ? started.timestamp : void 0;
+  const status = lastCompleted ? lastCompleted.status : started ? "running" : "unknown";
+  const steps = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.event === "step_started") {
+      const s = e;
+      steps.set(s.stepId, {
+        name: s.name,
+        type: s.type,
+        parentId: s.parentId,
+        startedAt: finite(s.startTime) ? s.startTime : s.timestamp,
+        status: "running",
+        metadata: s.metadata
+      });
+    }
+  }
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const c = e;
+    const node = steps.get(c.stepId);
+    if (!node) continue;
+    node.status = c.status;
+    if (finite(c.durationMs)) node.durationMs = c.durationMs;
+  }
+  const depthCache = /* @__PURE__ */ new Map();
+  const computeDepth = (stepId) => {
+    const cached = depthCache.get(stepId);
+    if (cached !== void 0) return cached;
+    const node = steps.get(stepId);
+    if (!node) return 0;
+    const parent = node.parentId;
+    if (typeof parent !== "string" || parent.trim() === "" || !steps.has(parent)) {
+      depthCache.set(stepId, 0);
+      return 0;
+    }
+    const d = Math.min(1e3, computeDepth(parent) + 1);
+    depthCache.set(stepId, d);
+    return d;
+  };
+  const entries = [];
+  for (const [stepId, s] of steps.entries()) {
+    const offsetMs = runStart !== void 0 && finite(s.startedAt) ? Math.max(0, s.startedAt - runStart) : 0;
+    entries.push({
+      stepId,
+      name: s.name,
+      type: s.type,
+      status: s.status,
+      depth: computeDepth(stepId),
+      startedAt: s.startedAt,
+      offsetMs,
+      durationMs: s.durationMs,
+      isError: s.status === "error",
+      streaming: pickStreamingMeta(s.metadata)
+    });
+  }
+  entries.sort((a, b) => a.startedAt - b.startedAt);
+  const slowTopN = options.slowTopN ?? 3;
+  if (options.focus === "slow" && entries.length > 0) {
+    const ranked = [...entries].filter((e) => finite(e.durationMs)).sort((a, b) => (b.durationMs ?? 0) - (a.durationMs ?? 0));
+    const slowIds = new Set(
+      ranked.slice(0, slowTopN).map((e) => e.stepId)
+    );
+    for (const e of entries) {
+      if (slowIds.has(e.stepId)) e.slow = true;
+    }
+  }
+  return {
+    runId,
+    name: typeof started?.name === "string" && started.name.trim() !== "" ? started.name : void 0,
+    status,
+    startedAt: runStart,
+    endedAt: lastCompleted && finite(lastCompleted.endTime) ? lastCompleted.endTime : void 0,
+    durationMs: lastCompleted && finite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0,
+    correlation: pickCorrelation(
+      started?.metadata
+    ),
+    entries
+  };
+}
+
+// packages/core/src/search.ts
+function parseDurationFilter(expr) {
+  const raw = expr.trim();
+  const m = raw.match(/^(>=|<=|>|<)\s*(.+)$/);
+  if (!m) {
+    throw new Error(
+      `Invalid --duration "${expr}". Use forms like >5s, >=500ms, <2m.`
+    );
+  }
+  const op = m[1];
+  const ms = parseDuration(m[2].trim());
+  return { op, ms };
+}
+function durationMatches(valueMs, filter) {
+  if (valueMs === void 0 || !Number.isFinite(valueMs)) return false;
+  switch (filter.op) {
+    case ">":
+      return valueMs > filter.ms;
+    case ">=":
+      return valueMs >= filter.ms;
+    case "<":
+      return valueMs < filter.ms;
+    case "<=":
+      return valueMs <= filter.ms;
+    default:
+      return false;
+  }
+}
+function normalizeStepTypeFilter(kind, type) {
+  const v = (kind ?? type)?.trim().toLowerCase();
+  return v && v !== "" ? v : void 0;
+}
+function nameMatches(hay, needle) {
+  return hay.toLowerCase().includes(needle.toLowerCase());
+}
+async function searchTraces(metas, options) {
+  let filtered = filterTraces(metas, { since: options.since });
+  const stepTypeFilter = normalizeStepTypeFilter(options.kind, options.type);
+  const nameQuery = options.name?.trim();
+  const toolQuery = options.tool?.trim();
+  let durationFilter;
+  if (options.duration) {
+    durationFilter = parseDurationFilter(options.duration);
+  }
+  const limit = options.limit;
+  const sessionId = options.session?.trim();
+  const hasContentFilter = Boolean(
+    options.status || stepTypeFilter || nameQuery || toolQuery || durationFilter
+  );
+  const results = [];
+  const sessionLabel = sessionId && sessionId !== "" ? sessionId : void 0;
+  if (!hasContentFilter) {
+    for (const m of filtered) {
+      results.push({
+        runId: m.runId,
+        runName: m.name,
+        runStatus: m.status,
+        timestamp: m.startedAt,
+        durationMs: m.durationMs,
+        matchReason: sessionLabel ? `trace in session ${sessionLabel}` : "trace in directory",
+        matchedFields: sessionLabel ? ["run", "session"] : ["run"],
+        filePath: m.filePath,
+        ...sessionLabel ? { sessionId: sessionLabel } : {}
+      });
+    }
+    return results.slice(0, limit);
+  }
+  for (const m of filtered) {
+    if (options.status && m.status !== options.status) continue;
+    let events = [];
+    try {
+      events = await readTraceEventsFromFile(m.filePath);
+    } catch {
+      continue;
+    }
+    if (events.length === 0) continue;
+    const runMatches = matchRunLevel(m, {
+      stepTypeFilter,
+      nameQuery,
+      toolQuery,
+      durationFilter,
+      statusFilter: options.status
+    });
+    results.push(...runMatches);
+    const stepMatches = matchStepLevel(m, events, {
+      stepTypeFilter,
+      nameQuery,
+      toolQuery,
+      durationFilter,
+      statusFilter: options.status
+    });
+    results.push(...stepMatches);
+  }
+  results.sort((a, b) => {
+    const ta = a.timestamp ?? 0;
+    const tb = b.timestamp ?? 0;
+    if (ta !== tb) return ta - tb;
+    const runCmp = a.runId.localeCompare(b.runId);
+    if (runCmp !== 0) return runCmp;
+    return (a.stepName ?? "").localeCompare(b.stepName ?? "");
+  });
+  return results.slice(0, limit);
+}
+function matchRunLevel(m, opts) {
+  if (opts.stepTypeFilter || opts.toolQuery) return [];
+  const out = [];
+  const fields = [];
+  if (opts.statusFilter && m.status === opts.statusFilter) {
+    fields.push("run.status");
+  }
+  if (opts.nameQuery && nameMatches(m.name ?? m.runId, opts.nameQuery)) {
+    fields.push("run.name");
+  }
+  if (opts.durationFilter && durationMatches(m.durationMs, opts.durationFilter)) {
+    fields.push("run.durationMs");
+  }
+  if (fields.length === 0) return out;
+  out.push({
+    runId: m.runId,
+    runName: m.name,
+    runStatus: m.status,
+    timestamp: m.startedAt,
+    durationMs: m.durationMs,
+    matchReason: `run match: ${fields.join(", ")}`,
+    matchedFields: fields,
+    filePath: m.filePath
+  });
+  return out;
+}
+function matchStepLevel(m, events, opts) {
+  const out = [];
+  const started = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.event === "step_started") {
+      started.set(e.stepId, e);
+    }
+  }
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const c = e;
+    const s = started.get(c.stepId);
+    if (!s) continue;
+    const fields = [];
+    const stepType = s.type;
+    if (opts.stepTypeFilter && stepType !== opts.stepTypeFilter) {
+      continue;
+    }
+    const hasStepFilters = opts.stepTypeFilter || opts.nameQuery || opts.toolQuery || opts.durationFilter || opts.statusFilter === "error" || opts.statusFilter === "success";
+    if (!hasStepFilters) continue;
+    if (opts.statusFilter === "error" && c.status === "error") {
+      fields.push("step.status");
+    } else if (opts.statusFilter === "success" && c.status === "success") {
+      fields.push("step.status");
+    } else if (opts.statusFilter === "error" || opts.statusFilter === "success") {
+      continue;
+    }
+    if (opts.nameQuery) {
+      if (!nameMatches(s.name, opts.nameQuery)) continue;
+      fields.push("step.name");
+    }
+    if (opts.toolQuery) {
+      const toolName = typeof s.metadata?.toolName === "string" ? s.metadata.toolName : s.name;
+      if (!nameMatches(toolName, opts.toolQuery)) continue;
+      fields.push("step.tool");
+    }
+    if (opts.durationFilter) {
+      if (!durationMatches(c.durationMs, opts.durationFilter)) continue;
+      fields.push("step.durationMs");
+    }
+    if (opts.stepTypeFilter) {
+      fields.push("step.type");
+    }
+    if (fields.length === 0) continue;
+    out.push({
+      runId: m.runId,
+      runName: m.name,
+      runStatus: m.status,
+      stepId: c.stepId,
+      stepName: s.name,
+      stepType,
+      timestamp: s.startTime ?? s.timestamp,
+      durationMs: c.durationMs,
+      matchReason: `step match: ${fields.join(", ")}`,
+      matchedFields: fields,
+      filePath: m.filePath
+    });
+  }
+  return out;
+}
+async function loadTraceMetadataList(_traceDir, fileNames, getPath) {
+  const metas = [];
+  for (const fileName of fileNames) {
+    try {
+      const filePath = getPath(fileName);
+      const meta = await extractMetadata(filePath);
+      metas.push(meta);
+    } catch {
+    }
+  }
+  return metas;
+}
+
+// packages/core/src/checks/index.ts
+var SEVERITY_RANK = {
+  error: 0,
+  warning: 1,
+  info: 2
+};
+var STATUS_RANK = {
+  fail: 0,
+  warning: 1,
+  pass: 2
+};
+function compareStrings(a, b) {
+  return (a ?? "").localeCompare(b ?? "");
+}
+function diagnostic(code, message, ruleId) {
+  return {
+    code,
+    message,
+    severity: "error",
+    ...ruleId ? { ruleId } : {}
+  };
+}
+function emptySummary() {
+  return {
+    passed: 0,
+    failed: 0,
+    warnings: 0,
+    errors: 0
+  };
+}
+function errorResult(input, diagnostics, selectedRun) {
+  return {
+    ok: false,
+    status: "error",
+    format: input.read.format,
+    ...selectedRun ? { runId: selectedRun.runId } : {},
+    summary: {
+      ...emptySummary(),
+      errors: diagnostics.filter((item) => item.severity === "error").length
+    },
+    findings: [],
+    diagnostics: [...diagnostics]
+  };
+}
+function flattenNodes(nodes) {
+  return nodes.flatMap((node) => [node, ...flattenNodes(node.children)]);
+}
+function buildFacts(input, selectedRun) {
+  const scopedRuns = selectedRun ? [selectedRun] : input.read.runs;
+  const scopedRunIds = new Set(scopedRuns.map((run) => run.runId));
+  const scopedEvents = selectedRun === void 0 ? input.read.events : input.read.events.filter((event) => scopedRunIds.has(event.runId));
+  const nodes = flattenNodes(scopedRuns.flatMap((run) => run.children));
+  const nodesByEventId = /* @__PURE__ */ new Map();
+  const childrenByParentId = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodesByEventId.set(node.event.eventId, node);
+    const parentId = node.event.parentId;
+    if (parentId) {
+      const children = childrenByParentId.get(parentId) ?? [];
+      children.push(node);
+      childrenByParentId.set(parentId, children);
+    }
+  }
+  return {
+    format: input.read.format,
+    runs: Object.freeze([...input.read.runs]),
+    events: Object.freeze([...scopedEvents]),
+    readerWarnings: Object.freeze([...input.read.warnings]),
+    unsupportedFields: Object.freeze([...input.read.unsupportedFields]),
+    sourceFiles: Object.freeze([...input.read.sourceFiles]),
+    nodesByEventId,
+    childrenByParentId,
+    rootNodes: Object.freeze(scopedRuns.flatMap((run) => run.children))
+  };
+}
+function resolveSelectedRun(input, runId) {
+  if (input.selectedRun) {
+    if (runId && input.selectedRun.runId !== runId) {
+      return {
+        diagnostics: [
+          diagnostic(
+            "AI_CHECK_INVALID_ARGUMENTS",
+            `Selected run ${input.selectedRun.runId} does not match requested run ${runId}.`
+          )
+        ]
+      };
+    }
+    return { run: input.selectedRun, diagnostics: [] };
+  }
+  if (runId) {
+    const run = input.read.runs.find((candidate) => candidate.runId === runId);
+    if (!run) {
+      return {
+        diagnostics: [
+          diagnostic("AI_CHECK_RUN_SELECTION_REQUIRED", `Run not found: ${runId}.`)
+        ]
+      };
+    }
+    return { run, diagnostics: [] };
+  }
+  if (input.read.runs.length === 1) {
+    return { run: input.read.runs[0], diagnostics: [] };
+  }
+  if (input.read.runs.length === 0) {
+    return {
+      diagnostics: [
+        diagnostic("AI_CHECK_RUN_SELECTION_REQUIRED", "No runs are available for checks.")
+      ]
+    };
+  }
+  return {
+    diagnostics: [
+      diagnostic(
+        "AI_CHECK_RUN_SELECTION_REQUIRED",
+        "Multiple runs are available; select a run before executing checks."
+      )
+    ]
+  };
+}
+function selectRules(rules, selectedIds) {
+  const diagnostics = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (byId.has(rule.id)) {
+      diagnostics.push(
+        diagnostic("AI_CHECK_INVALID_CONFIG", `Duplicate trace check rule id: ${rule.id}.`, rule.id)
+      );
+      continue;
+    }
+    byId.set(rule.id, rule);
+  }
+  if (selectedIds && selectedIds.length > 0) {
+    const selected = new Set(selectedIds);
+    for (const id of selected) {
+      if (!byId.has(id)) {
+        diagnostics.push(
+          diagnostic("AI_CHECK_INVALID_CONFIG", `Unknown trace check rule id: ${id}.`, id)
+        );
+      }
+    }
+    return {
+      rules: [...byId.values()].filter((rule) => selected.has(rule.id)).sort(compareRules),
+      diagnostics
+    };
+  }
+  return { rules: [...byId.values()].sort(compareRules), diagnostics };
+}
+function compareRules(a, b) {
+  return a.id.localeCompare(b.id);
+}
+function eventTimestamp(finding, eventById) {
+  const eventId = finding.evidence[0]?.eventId;
+  return eventId ? eventById.get(eventId)?.timestamp ?? "" : "";
+}
+function compareFindings(eventById) {
+  return (a, b) => {
+    if (SEVERITY_RANK[a.severity] !== SEVERITY_RANK[b.severity]) {
+      return SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity];
+    }
+    const byRule = a.ruleId.localeCompare(b.ruleId);
+    if (byRule !== 0) return byRule;
+    if (STATUS_RANK[a.status] !== STATUS_RANK[b.status]) {
+      return STATUS_RANK[a.status] - STATUS_RANK[b.status];
+    }
+    const byRun = compareStrings(a.evidence[0]?.runId, b.evidence[0]?.runId);
+    if (byRun !== 0) return byRun;
+    const byTime = eventTimestamp(a, eventById).localeCompare(eventTimestamp(b, eventById));
+    if (byTime !== 0) return byTime;
+    const byEvent = compareStrings(a.evidence[0]?.eventId, b.evidence[0]?.eventId);
+    if (byEvent !== 0) return byEvent;
+    return compareStrings(a.evidence[0]?.path, b.evidence[0]?.path);
+  };
+}
+function normalizeFinding(rule, finding) {
+  return {
+    ruleId: finding.ruleId || rule.id,
+    severity: finding.severity ?? rule.defaultSeverity,
+    status: finding.status,
+    message: finding.message,
+    ...finding.expected !== void 0 ? { expected: finding.expected } : {},
+    ...finding.actual !== void 0 ? { actual: finding.actual } : {},
+    evidence: [...finding.evidence ?? []]
+  };
+}
+function summarize(findings, diagnostics) {
+  return {
+    passed: findings.filter((finding) => finding.status === "pass").length,
+    failed: findings.filter(
+      (finding) => finding.status === "fail" && finding.severity === "error"
+    ).length,
+    warnings: findings.filter(
+      (finding) => finding.status === "warning" || finding.severity === "warning"
+    ).length,
+    errors: diagnostics.filter((item) => item.severity === "error").length
+  };
+}
+function eventEvidence(event, path7) {
+  return {
+    runId: event.runId,
+    eventId: event.eventId,
+    parentId: event.parentId,
+    traceId: event.trace?.traceId,
+    spanId: event.trace?.spanId,
+    kind: event.kind,
+    name: event.name,
+    status: event.status,
+    ...{}
+  };
+}
+function runEvidence(run) {
+  return run ? [{ runId: run.runId, name: run.name, status: run.status }] : [];
+}
+function failFinding(ruleId, message, evidence, expected, actual) {
+  return {
+    ruleId,
+    severity: "error",
+    status: "fail",
+    message,
+    ...expected !== void 0 ? { expected } : {},
+    ...actual !== void 0 ? { actual } : {},
+    evidence: [...evidence]
+  };
+}
+function createRunStatusRule(options = {}) {
+  const expected = options.expected ?? "ok";
+  const allowIncomplete = options.allowIncomplete === true;
+  return {
+    id: "run.status",
+    category: "run",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const findings = [];
+      const actual = context.selectedRun?.status ?? "unknown";
+      if (actual !== expected) {
+        findings.push(
+          failFinding(
+            "run.status",
+            `Run status ${actual} did not match expected ${expected}.`,
+            runEvidence(context.selectedRun),
+            expected,
+            actual
+          )
+        );
+      }
+      if (!allowIncomplete) {
+        const running = context.events.filter((event) => event.status === "running");
+        if (running.length > 0) {
+          findings.push(
+            failFinding(
+              "run.status",
+              "Run contains incomplete running events.",
+              running.map((event) => eventEvidence(event)),
+              "no running events",
+              running.length
+            )
+          );
+        }
+      }
+      return findings;
+    }
+  };
+}
+function runTraceChecks(input, options = {}) {
+  const selected = resolveSelectedRun(input, options.runId);
+  if (selected.diagnostics.length > 0) {
+    return errorResult(input, selected.diagnostics, selected.run);
+  }
+  const rules = selectRules(options.rules ?? [], options.select);
+  if (rules.diagnostics.length > 0) {
+    return errorResult(input, rules.diagnostics, selected.run);
+  }
+  const facts = buildFacts(input, selected.run);
+  const context = {
+    ...facts,
+    ...selected.run ? { selectedRun: selected.run } : {},
+    ...input.sourceLabel ? { sourceLabel: input.sourceLabel } : {}
+  };
+  const diagnostics = [];
+  const findings = [];
+  for (const rule of rules.rules) {
+    try {
+      findings.push(...rule.evaluate(context).map((finding) => normalizeFinding(rule, finding)));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      diagnostics.push(
+        diagnostic("AI_CHECK_INTERNAL_ERROR", `Rule ${rule.id} failed: ${message}`, rule.id)
+      );
+    }
+  }
+  if (diagnostics.length > 0) {
+    return errorResult(input, diagnostics, selected.run);
+  }
+  const eventById = new Map(input.read.events.map((event) => [event.eventId, event]));
+  const sortedFindings = findings.sort(compareFindings(eventById));
+  const summary = summarize(sortedFindings, diagnostics);
+  const status = summary.failed > 0 ? "fail" : "pass";
+  return {
+    ok: status === "pass",
+    status,
+    format: input.read.format,
+    ...selected.run ? { runId: selected.run.runId } : {},
+    summary,
+    findings: sortedFindings,
+    diagnostics
+  };
+}
+
+// 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 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);
+  }
+  return {
+    runId,
+    name: rs.name,
+    status: runStatus,
+    durationMs,
+    steps: roots
+  };
+}
+
+// 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;
+  }
+  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`;
+  }
+  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]);
+  }
+  return out;
+}
+function stableJson(value, pretty) {
+  const sorted = sortKeysDeep(value);
+  return pretty === true ? JSON.stringify(sorted, null, 2) : JSON.stringify(sorted);
+}
+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;
+    }
+    const v = attrs[key];
+    out[key] = compactValue(v, maxLen);
+  }
+  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);
+    }
+  }
+  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 };
+}
+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;
+      }
+    }
+    if (R === void 0) {
+      R = right.find(
+        (r) => !usedRight.has(r.id) && r.name === L.name && (r.type ?? "") === (L.type ?? "")
+      );
+    }
+    if (R !== void 0) {
+      usedRight.add(R.id);
+      pairs.push([L, R]);
+    } else {
+      pairs.push([L, void 0]);
+    }
+  }
+  for (const R of right) {
+    if (!usedRight.has(R.id)) {
+      pairs.push([void 0, R]);
+    }
+  }
+  return pairs;
+}
+function compareLeafSteps(L, R, segments, opts, out) {
+  const path7 = buildPath(segments);
+  if (L.name !== R.name) {
+    out.push({
+      kind: "structure",
+      severity: "warning",
+      message: "Step name differs",
+      path: path7,
+      left: L.name,
+      right: R.name
+    });
+  }
+  if ((L.type ?? "") !== (R.type ?? "")) {
+    out.push({
+      kind: "step-type",
+      severity: "warning",
+      message: "Step type differs",
+      path: path7,
+      left: L.type,
+      right: R.type
+    });
+  }
+  if ((L.status ?? "") !== (R.status ?? "")) {
+    out.push({
+      kind: "step-status",
+      severity: "warning",
+      message: "Step status differs",
+      path: path7,
+      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: path7,
+      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: path7,
+        left: ld,
+        right: rd
+      });
+    }
+  }
+  const lm = stableJson(L.metadata ?? {});
+  const rm = stableJson(R.metadata ?? {});
+  if (lm !== rm) {
+    out.push({
+      kind: "metadata",
+      severity: "info",
+      message: "Step metadata differs",
+      path: path7,
+      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: path7,
+      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
+      });
+    }
+    ci += 1;
+  }
+}
+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 pairs = pairSteps(left.steps, right.steps);
+  let idx = 0;
+  for (const [ls, rs] of pairs) {
+    if (ls !== void 0 && rs !== void 0) {
+      compareRecursive(ls, rs, [pathSeg(ls, idx)], opts, raw);
+      idx += 1;
+    } else if (ls !== void 0) {
+      raw.push({
+        kind: "step-removed",
+        severity: "warning",
+        message: `Step only in left run: ${ls.name}`,
+        path: buildPath([pathSeg(ls, idx)]),
+        left: ls.id,
+        right: void 0
+      });
+      idx += 1;
+    } else if (rs !== void 0) {
+      raw.push({
+        kind: "step-added",
+        severity: "warning",
+        message: `Step only in right run: ${rs.name}`,
+        path: buildPath([pathSeg(rs, idx)]),
+        left: void 0,
+        right: rs.id
+      });
+      idx += 1;
+    }
+  }
+  const differences = raw.filter((d) => kindMatchesFilter(d.kind));
+  let errors = 0;
+  let warnings = 0;
+  let info = 0;
+  for (const d of differences) {
+    if (d.severity === "error") errors += 1;
+    else if (d.severity === "warning") warnings += 1;
+    else info += 1;
+  }
+  const firstVisible = differences[0];
+  const firstDivergence = firstVisible !== void 0 ? {
+    kind: "first-divergence",
+    severity: firstVisible.severity,
+    message: `First divergence: ${firstVisible.message}`,
+    path: firstVisible.path,
+    left: firstVisible.left,
+    right: firstVisible.right
+  } : void 0;
+  const summary = {
+    leftRunId: left.runId,
+    rightRunId: right.runId,
+    totalDifferences: differences.length,
+    errors,
+    warnings,
+    info,
+    firstDivergence
+  };
+  return { summary, differences };
+}
+
+// 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("");
+  }
+  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 (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."
+    );
+  }
+  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;
+}
+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 {
+    ...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;
+    default:
+      return "unknown";
+  }
+}
+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 { iso: new Date(ms).toISOString(), invalidTimestamp: false };
+}
+function buildSource(options) {
+  return {
+    type: "manual",
+    name: options?.sourceName ?? "trace-event",
+    version: options?.sourceVersion ?? "0.1"
+  };
+}
+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";
+  }
+}
+function mapRunOrStepStatus(status) {
+  return status === "success" ? "ok" : "error";
+}
+function mapErrorInfo(error) {
+  if (!error?.message) {
+    return {};
+  }
+  const out = {
+    persisted: {
+      message: error.message,
+      name: "Error"
+    }
+  };
+  if (typeof error.stack === "string" && error.stack.length > 0) {
+    out.errorStack = error.stack;
+  }
+  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;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+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
+      };
+    }
+    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
+      };
+    }
+    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;
+      }
+      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
+      };
+    }
+    default: {
+      const _exhaustive = event;
+      throw new Error(`Unsupported trace event: ${_exhaustive.event}`);
+    }
+  }
+}
+function traceEventsToPersistedInspectEvents(events, options) {
+  return events.map(
+    (event, index) => traceEventToPersistedInspectEvent(event, { ...options, eventIndex: index })
+  );
+}
+
+// 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;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+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 {
+    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 (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";
+  }
+  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 (status !== void 0) {
+    out.status = status;
+  }
+  if (event.durationMs !== void 0 && Number.isFinite(event.durationMs) && event.durationMs >= 0) {
+    out.durationMs = event.durationMs;
+  }
+  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));
+  }
+  return out;
+}
+
+// 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;
+  }
+  if (hasRunning) return "running";
+  return "ok";
+}
+var TreeBuilder = class {
+  constructor(options) {
+    void options?.config;
+  }
+  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;
+  }
+};
+
+// packages/core/src/persisted/tree-bridge.ts
+function persistedInspectEventsToRunTrees(events, options) {
+  const inspectEvents = persistedInspectEventsToInspectEvents(events, {
+    skipInvalid: options?.skipInvalid
+  });
+  return new TreeBuilder().build(inspectEvents);
+}
+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 promises.readdir(dirPath, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path__default.default.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 } : {}
+    }
+  ]);
+}
+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 promises.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 promises.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;
+    }
+    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;
+  }
+  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 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";
+  }
+}
+function persistedEventsForParsedTrace(parsed) {
+  if ((parsed.format === "0.2" || parsed.format === "1.0") && parsed.persisted.length > 0) {
+    return [...parsed.persisted];
+  }
+  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 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 void 0;
+}
+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 {
+      spans,
+      confidence: 0.82,
+      description: "OpenInference span array",
+      warnings,
+      unsupportedFields
+    };
+  }
+  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 {
+      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"
+      });
+    }
+    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,
+      warnings,
+      unsupportedFields
+    };
+  }
+  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
+    };
+  }
+  return void 0;
+}
+function parseUnixNanoToIso(value) {
+  if (typeof value === "bigint" && value >= 0n) {
+    return new Date(Number(value / 1000000n)).toISOString();
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return new Date(Math.floor(value / 1e6)).toISOString();
+  }
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    return new Date(Number(BigInt(value) / 1000000n)).toISOString();
+  }
+  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;
+  }
+  for (const key of isoKeys) {
+    const iso = parseIsoTime(span[key]);
+    if (iso !== void 0) return iso;
+  }
+  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;
+  }
+  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")
+  );
+}
+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 };
+  }
+  if (value === null) {
+    return { type: "null" };
+  }
+  return { type: typeof value };
+}
+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 };
+}
+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") {
+    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 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";
+  }
+}
+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 (typeof completion === "number" && Number.isFinite(completion) && completion >= 0) {
+    usage.output = completion;
+  }
+  if (typeof total === "number" && Number.isFinite(total) && total >= 0) {
+    usage.total = total;
+  }
+  if (typeof cached === "number" && Number.isFinite(cached) && cached >= 0) {
+    usage.cached = cached;
+  }
+  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 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 = [];
+  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: "openinference_missing_start_time",
+      message: "OpenInference span is missing a valid start time; using Unix epoch.",
+      severity: "warning",
+      field: `${pathPrefix}.start_time_unix_nano`
+    });
+    unsupportedFields.push(`${pathPrefix}.start_time_unix_nano`);
+  }
+  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;
+  }
+  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 : "OpenInference span error"
+    };
+  }
+  return {
+    event,
+    warnings,
+    unsupportedFields,
+    spanId,
+    ...parentSpanId !== void 0 ? { parentSpanId } : {}
+  };
+}
+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)
+  };
+}
+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 {
+      format: OPENINFERENCE_READER_FORMAT,
+      confidence: document.confidence,
+      readerName: "OpenInference JSON",
+      description: document.description,
+      warnings: attachSingleSourceFile(document.warnings, resolved)
+    };
+  },
+  async read(input) {
+    const resolved = await resolveInput(input);
+    if (!resolved) {
+      throw new TraceReadError(
+        "unsupported_format",
+        "OpenInference 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.", [
+        {
+          code: "openinference_invalid_json",
+          message: "OpenInference JSON reader could not parse the input as JSON.",
+          severity: "error"
+        }
+      ]);
+    }
+    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 {
+      format: OPENINFERENCE_READER_FORMAT,
+      events: mapped.events,
+      runs: persistedInspectEventsToRunTrees(mapped.events, { skipInvalid: true }),
+      warnings,
+      unsupportedFields,
+      sourceFiles: resolved.sourceFiles
+    };
+  }
+};
+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
+      );
+    }
+    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 };
+  }
+  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 { 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 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;
+      }
+      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 (spans.length === 0) {
+    warnings.push({
+      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 {
+    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") {
+    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;
+  }
+  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
+    )
+  };
+}
+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;
+  }
+  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}`
+      });
+    }
+  }
+  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,
+    ["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 { 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 } : {}
+    }
+  };
+  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"
+    };
+  }
+  return {
+    event,
+    warnings,
+    unsupportedFields,
+    spanId,
+    ...parentSpanId !== void 0 ? { parentSpanId } : {}
+  };
+}
+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;
+  }
+  return {
+    events: mapped.map((span) => span.event),
+    warnings: mapped.flatMap((span) => span.warnings),
+    unsupportedFields: mapped.flatMap((span) => span.unsupportedFields)
+  };
+}
+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;
+    }
+    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."
+      );
+    }
+    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
+        )
+      );
+    }
+    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.");
+    }
+    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
+    };
+  }
+};
+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: []
+    };
+  }
+  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"
+      });
+    }
+  }
+  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 {
+      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"
+        }
+      ]
+    };
+  }
+  return {
+    status: "detected",
+    format: best.format,
+    candidates: sorted,
+    warnings: allWarnings
+  };
+}
+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
+    );
+  }
+  if (detection.status === "ambiguous") {
+    throw new TraceReadError(
+      "ambiguous_format",
+      "Multiple trace readers matched the input with equal confidence.",
+      detection.warnings
+    );
+  }
+  const reader = findReaderByFormat(detection.format, readers);
+  if (!reader) {
+    throw new TraceReadError(
+      "unsupported_format",
+      `No trace reader is registered for format "${detection.format}".`,
+      detection.warnings
+    );
+  }
+  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])
+      );
+    }
+    throw new TraceReadError(
+      "reader_failed",
+      error instanceof Error && error.message.trim() !== "" ? error.message : `Trace reader "${reader.format}" failed.`,
+      detection.warnings
+    );
+  }
+}
+function openTrace(input, options = {}) {
+  return readTrace(input, options);
+}
+
+// packages/mcp-server/src/tools.ts
+var READ_ONLY_TOOLS = [
+  {
+    name: "list_traces",
+    description: "List local trace runs in the configured trace directory.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "read_trace",
+    description: "Read a bounded trace projection for one run id.",
+    inputSchema: {
+      type: "object",
+      properties: { runId: { type: "string" } },
+      required: ["runId"]
+    }
+  },
+  {
+    name: "search_traces",
+    description: "Search traces deterministically by query string.",
+    inputSchema: {
+      type: "object",
+      properties: { query: { type: "string" } },
+      required: ["query"]
+    }
+  },
+  {
+    name: "find_first_error",
+    description: "Find the first error step in one run timeline.",
+    inputSchema: {
+      type: "object",
+      properties: { runId: { type: "string" } },
+      required: ["runId"]
+    }
+  },
+  {
+    name: "find_slowest_path",
+    description: "Summarize the slowest steps in one run.",
+    inputSchema: {
+      type: "object",
+      properties: { runId: { type: "string" } },
+      required: ["runId"]
+    }
+  },
+  {
+    name: "compare_runs",
+    description: "Compare two runs and return a bounded structural diff summary.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        leftRunId: { type: "string" },
+        rightRunId: { type: "string" }
+      },
+      required: ["leftRunId", "rightRunId"]
+    }
+  },
+  {
+    name: "run_checks",
+    description: "Run deterministic run.status check for one run.",
+    inputSchema: {
+      type: "object",
+      properties: { runId: { type: "string" } },
+      required: ["runId"]
+    }
+  },
+  {
+    name: "create_share_safe_report",
+    description: "Create a share-profile markdown report for one run.",
+    inputSchema: {
+      type: "object",
+      properties: { runId: { type: "string" } },
+      required: ["runId"]
+    }
+  }
+];
+function textResult(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    isError: false
+  };
+}
+function errorResult2(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+async function resolveMeta(context, runId) {
+  const td = new TraceDirectory({ dir: context.traceDir });
+  const files = await td.list();
+  const metas = await loadTraceMetadataList(
+    context.traceDir,
+    files,
+    (fileName) => td.getPath(fileName)
+  );
+  const meta = metas.find((item) => item.runId === runId);
+  if (!meta) throw new Error(`Run not found: ${runId}`);
+  return meta;
+}
+async function openRunTrace(context, runId) {
+  const meta = await resolveMeta(context, runId);
+  const read = await openTrace({ type: "file", path: meta.filePath });
+  return { meta, read };
+}
+function legacyTraceEvents(events) {
+  return persistedInspectEventsToTraceEvents(events);
+}
+async function callReadOnlyTool(context, name, args = {}) {
+  switch (name) {
+    case "list_traces": {
+      const td = new TraceDirectory({ dir: context.traceDir });
+      const files = await td.list();
+      const metas = await loadTraceMetadataList(
+        context.traceDir,
+        files,
+        (fileName) => td.getPath(fileName)
+      );
+      return textResult(
+        metas.map((meta) => ({
+          runId: meta.runId,
+          name: meta.name,
+          status: meta.status,
+          file: path__default.default.basename(meta.filePath)
+        }))
+      );
+    }
+    case "read_trace": {
+      const runId = String(args.runId ?? "");
+      const { read } = await openRunTrace(context, runId);
+      const events = read.events.length > context.maxEvents ? read.events.slice(0, context.maxEvents) : read.events;
+      return textResult({
+        runId,
+        format: read.format,
+        truncated: read.events.length > events.length,
+        events
+      });
+    }
+    case "search_traces": {
+      const query = String(args.query ?? "").trim();
+      if (!query) return errorResult2("query is required");
+      const td = new TraceDirectory({ dir: context.traceDir });
+      const files = await td.list();
+      const metas = await loadTraceMetadataList(
+        context.traceDir,
+        files,
+        (fileName) => td.getPath(fileName)
+      );
+      const results = await searchTraces(metas, {
+        traceDir: context.traceDir,
+        name: query,
+        limit: 25
+      });
+      return textResult(results);
+    }
+    case "find_first_error": {
+      const runId = String(args.runId ?? "");
+      const { read } = await openRunTrace(context, runId);
+      const timeline = buildRunTimeline(legacyTraceEvents(read.events));
+      const firstError = timeline.entries.find((entry) => entry.isError);
+      return textResult({
+        runId,
+        firstError: firstError ?? null
+      });
+    }
+    case "find_slowest_path": {
+      const runId = String(args.runId ?? "");
+      const { read } = await openRunTrace(context, runId);
+      const timeline = buildRunTimeline(legacyTraceEvents(read.events), {
+        focus: "slow",
+        slowTopN: 5
+      });
+      const ranked = [...timeline.entries].filter((entry) => entry.durationMs !== void 0 && Number.isFinite(entry.durationMs)).sort((a, b) => (b.durationMs ?? 0) - (a.durationMs ?? 0)).slice(0, 5);
+      return textResult({
+        runId,
+        slowest: ranked[0] ?? null,
+        top: ranked
+      });
+    }
+    case "compare_runs": {
+      const leftRunId = String(args.leftRunId ?? "");
+      const rightRunId = String(args.rightRunId ?? "");
+      const left = await openRunTrace(context, leftRunId);
+      const right = await openRunTrace(context, rightRunId);
+      const diff = diffRuns(
+        manualTraceEventsToComparableRun(legacyTraceEvents(left.read.events)),
+        manualTraceEventsToComparableRun(legacyTraceEvents(right.read.events))
+      );
+      return textResult({
+        summary: diff.summary,
+        differences: diff.differences.slice(0, 50),
+        truncated: diff.differences.length > 50
+      });
+    }
+    case "run_checks": {
+      const runId = String(args.runId ?? "");
+      const { read } = await openRunTrace(context, runId);
+      const result = runTraceChecks(
+        { read },
+        { rules: [createRunStatusRule()], select: ["run.status"], runId }
+      );
+      return textResult(result);
+    }
+    case "create_share_safe_report": {
+      const runId = String(args.runId ?? "");
+      const { read } = await openRunTrace(context, runId);
+      const run = read.runs.find((item) => item.runId === runId) ?? read.runs[0];
+      if (!run) return errorResult2(`Run tree not found: ${runId}`);
+      const markdown = exportMarkdown(run, {
+        redactionProfile: context.redactionProfile === "local" ? "share" : context.redactionProfile
+      });
+      return textResult({ runId, profile: context.redactionProfile, markdown: markdown.content });
+    }
+    default:
+      return errorResult2(`Unknown tool: ${name}`);
+  }
+}
+function createMcpServerContext(options = {}) {
+  return {
+    traceDir: resolveTraceDir({ dir: options.traceDir }),
+    maxEvents: options.maxEvents ?? 500,
+    redactionProfile: options.redactionProfile ?? "share"
+  };
+}
+
+// packages/mcp-server/src/index.ts
+async function runReadOnlyMcpServer(options = {}) {
+  const context = createMcpServerContext(options);
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const rl = readline__default.default.createInterface({ input, crlfDelay: Infinity });
+  const write = (line) => {
+    output.write(`${line}
+`);
+  };
+  const replyError = (id, code, message) => {
+    write(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id: id ?? null,
+        error: { code, message }
+      })
+    );
+  };
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let request;
+    try {
+      request = JSON.parse(line);
+    } catch {
+      write(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: -32700, message: "Parse error" }
+        })
+      );
+      continue;
+    }
+    const { id, method, params } = request;
+    try {
+      if (method === "initialize") {
+        write(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id,
+            result: {
+              protocolVersion: "2024-11-05",
+              serverInfo: { name: "@agent-inspect/mcp-server", version: "2.5.0" },
+              capabilities: { tools: {} }
+            }
+          })
+        );
+        continue;
+      }
+      if (method === "notifications/initialized") {
+        continue;
+      }
+      if (method === "tools/list") {
+        write(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id,
+            result: { tools: READ_ONLY_TOOLS }
+          })
+        );
+        continue;
+      }
+      if (method === "tools/call") {
+        const toolParams = params ?? {};
+        const result = await callReadOnlyTool(
+          context,
+          String(toolParams.name ?? ""),
+          toolParams.arguments ?? {}
+        );
+        write(JSON.stringify({ jsonrpc: "2.0", id, result }));
+        continue;
+      }
+      replyError(id, -32601, `Method not found: ${method}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      replyError(id, -32e3, message);
+    }
+  }
+}
+
+exports.READ_ONLY_TOOLS = READ_ONLY_TOOLS;
+exports.callReadOnlyTool = callReadOnlyTool;
+exports.createMcpServerContext = createMcpServerContext;
+exports.runReadOnlyMcpServer = runReadOnlyMcpServer;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map