agent-inspect 1.0.3 → 1.2.0

package/packages/core/dist/index.cjs

@@ -2,20 +2,21 @@
 
 var promises = require('fs/promises');
 var crypto = require('crypto');
-var nanoid = require('nanoid');
 var os = require('os');
 var path = require('path');
 var async_hooks = require('async_hooks');
 var fs = require('fs');
 var readline = require('readline');
-var chalk2 = require('chalk');
+var process2 = require('process');
+var tty = require('tty');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var os__default = /*#__PURE__*/_interopDefault(os);
 var path__default = /*#__PURE__*/_interopDefault(path);
-var chalk2__default = /*#__PURE__*/_interopDefault(chalk2);
+var process2__default = /*#__PURE__*/_interopDefault(process2);
+var tty__default = /*#__PURE__*/_interopDefault(tty);
 
 // packages/core/src/types.ts
 var STEP_TYPES = [
@@ -63,7 +64,743 @@ function isTraceEvent(value) {
       return false;
   }
 }
-function isRecord2(v) {
+
+// 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 isNonEmptyString(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 (!isNonEmptyString(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;
+  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") return false;
+  if (!isNonEmptyString(value.eventId)) return false;
+  if (!isNonEmptyString(value.runId)) return false;
+  if (!isInspectKind(value.kind)) return false;
+  if (!isNonEmptyString(value.name)) return false;
+  if (!isNonEmptyString(value.timestamp)) return false;
+  if (!isAttributionConfidence(value.confidence)) return false;
+  if (!isPersistedEventSource(value.source)) return false;
+  if (value.parentId !== void 0 && !isNonEmptyString(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/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) {
+  const tokens = metadata?.tokens;
+  if (!tokens || typeof tokens !== "object") {
+    return void 0;
+  }
+  const input = typeof tokens.input === "number" && Number.isFinite(tokens.input) && tokens.input >= 0 ? tokens.input : void 0;
+  const output = typeof tokens.output === "number" && Number.isFinite(tokens.output) && tokens.output >= 0 ? tokens.output : void 0;
+  if (input === void 0 && output === void 0) {
+    return void 0;
+  }
+  const usage = {};
+  if (input !== void 0) usage.input = input;
+  if (output !== void 0) usage.output = output;
+  if (input !== void 0 && output !== void 0) {
+    usage.total = input + output;
+  }
+  return usage;
+}
+function compactAttributes(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 attributes = compactAttributes({
+        legacyEvent: "run_started",
+        metadata: event.metadata !== void 0 ? { ...event.metadata } : void 0,
+        invalidTimestamp: tsMain.invalidTimestamp || tsStart.invalidTimestamp ? true : void 0
+      });
+      return {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: "RUN",
+        name: event.name,
+        status: "running",
+        timestamp: tsMain.iso,
+        startedAt: tsStart.iso,
+        confidence: "explicit",
+        source,
+        attributes
+      };
+    }
+    case "run_completed": {
+      const tsEnd = toIsoTimestamp(event.endTime);
+      const { persisted: error, errorStack } = mapErrorInfo(event.error);
+      const attributes = compactAttributes({
+        legacyEvent: "run_completed",
+        errorStack,
+        invalidTimestamp: tsMain.invalidTimestamp || tsEnd.invalidTimestamp ? true : void 0
+      });
+      return {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: "RUN",
+        name: "run",
+        status: mapRunOrStepStatus(event.status),
+        timestamp: tsMain.iso,
+        endedAt: tsEnd.iso,
+        durationMs: event.durationMs,
+        confidence: "explicit",
+        source,
+        attributes,
+        error
+      };
+    }
+    case "step_started": {
+      const tsStart = toIsoTimestamp(event.startTime);
+      const tokenUsage = mapTokenUsageFromMetadata(event.metadata);
+      const attributes = compactAttributes({
+        legacyEvent: "step_started",
+        stepId: event.stepId,
+        stepType: event.type,
+        metadata: event.metadata !== void 0 ? { ...event.metadata } : void 0,
+        invalidTimestamp: tsMain.invalidTimestamp || tsStart.invalidTimestamp ? true : void 0
+      });
+      const out = {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: mapStepTypeToInspectKind(event.type),
+        name: event.name,
+        status: "running",
+        timestamp: tsMain.iso,
+        startedAt: tsStart.iso,
+        confidence: "explicit",
+        source,
+        attributes
+      };
+      if (event.parentId !== void 0) {
+        out.parentId = event.parentId;
+      }
+      if (tokenUsage !== void 0) {
+        out.tokenUsage = tokenUsage;
+      }
+      return out;
+    }
+    case "step_completed": {
+      const tsEnd = toIsoTimestamp(event.endTime);
+      const { persisted: error, errorStack } = mapErrorInfo(event.error);
+      const attributes = compactAttributes({
+        legacyEvent: "step_completed",
+        stepId: event.stepId,
+        errorStack,
+        invalidTimestamp: tsMain.invalidTimestamp || tsEnd.invalidTimestamp ? true : void 0
+      });
+      return {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: "LOGIC",
+        name: event.stepId,
+        status: mapRunOrStepStatus(event.status),
+        timestamp: tsMain.iso,
+        endedAt: tsEnd.iso,
+        durationMs: event.durationMs,
+        confidence: "explicit",
+        source,
+        attributes,
+        error
+      };
+    }
+    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/from-inspect-event.ts
+function sanitizeIdPart2(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function createFallbackEventId(event, eventIndex) {
+  const runId = sanitizeIdPart2(event.runId);
+  const kind = sanitizeIdPart2(event.kind);
+  const name = sanitizeIdPart2(event.name);
+  return `inspect:${runId}:${kind}:${name}:${eventIndex}`;
+}
+function toIsoTimestamp2(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 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 mapInspectSourceToPersisted(source, options) {
+  const name = options?.sourceName;
+  const version = options?.sourceVersion;
+  switch (source.type) {
+    case "pino":
+      return {
+        persistedSource: {
+          type: "json-log",
+          name: name ?? "pino",
+          version
+        },
+        originalSourceType: "pino"
+      };
+    case "winston":
+      return {
+        persistedSource: {
+          type: "json-log",
+          name: name ?? "winston",
+          version
+        },
+        originalSourceType: "winston"
+      };
+    case "manual":
+    case "json-log":
+    case "log4js":
+    case "adapter":
+      return {
+        persistedSource: {
+          type: source.type,
+          name,
+          version
+        }
+      };
+    default:
+      return {
+        persistedSource: {
+          type: "json-log",
+          name,
+          version
+        }
+      };
+  }
+}
+function mapTokenUsageFromAttributes(attributes) {
+  const tokens = attributes?.tokens;
+  if (!tokens || typeof tokens !== "object" || Array.isArray(tokens)) {
+    return void 0;
+  }
+  const rec = tokens;
+  const input = typeof rec.input === "number" && Number.isFinite(rec.input) && rec.input >= 0 ? rec.input : void 0;
+  const output = typeof rec.output === "number" && Number.isFinite(rec.output) && rec.output >= 0 ? rec.output : void 0;
+  if (input === void 0 && output === void 0) {
+    return void 0;
+  }
+  const usage = {};
+  if (input !== void 0) usage.input = input;
+  if (output !== void 0) usage.output = output;
+  if (input !== void 0 && output !== void 0) {
+    usage.total = input + output;
+  }
+  return usage;
+}
+function mapErrorFromAttributes(event) {
+  if (event.status !== "error" || !event.attributes) {
+    return void 0;
+  }
+  const message = event.attributes.errorMessage;
+  if (typeof message !== "string" || message.length === 0) {
+    return void 0;
+  }
+  const err = { message };
+  if (typeof event.attributes.errorName === "string") {
+    err.name = event.attributes.errorName;
+  }
+  return err;
+}
+function inspectEventToPersistedInspectEvent(event, options) {
+  const eventIndex = options?.eventIndex ?? 0;
+  const eventId = typeof event.eventId === "string" && event.eventId.length > 0 ? event.eventId : createFallbackEventId(event, eventIndex);
+  const ts = toIsoTimestamp2(event.timestamp);
+  const { persistedSource, originalSourceType } = mapInspectSourceToPersisted(
+    event.source,
+    options
+  );
+  const attrsBase = event.attributes !== void 0 ? { ...event.attributes } : {};
+  const attributes = compactAttributes2({
+    ...attrsBase,
+    sourceFile: event.source.file,
+    sourceLine: event.source.line,
+    originalSourceType,
+    invalidTimestamp: ts.invalidTimestamp ? true : void 0
+  });
+  const tokenUsage = mapTokenUsageFromAttributes(event.attributes);
+  const error = mapErrorFromAttributes(event);
+  const inputPreview = event.attributes?.inputPreview;
+  const outputPreview = event.attributes?.outputPreview;
+  const out = {
+    schemaVersion: "0.2",
+    eventId,
+    runId: event.runId,
+    kind: event.kind,
+    name: event.name,
+    timestamp: ts.iso,
+    confidence: event.confidence,
+    source: persistedSource,
+    attributes
+  };
+  if (event.parentId !== void 0) {
+    out.parentId = event.parentId;
+  }
+  if (event.status !== void 0) {
+    out.status = event.status;
+  }
+  if (event.durationMs !== void 0 && Number.isFinite(event.durationMs) && event.durationMs >= 0) {
+    out.durationMs = event.durationMs;
+  }
+  if (tokenUsage !== void 0) {
+    out.tokenUsage = tokenUsage;
+  }
+  if (error !== void 0) {
+    out.error = error;
+  }
+  if (inputPreview !== void 0) {
+    out.inputSummary = inputPreview;
+  }
+  if (outputPreview !== void 0) {
+    out.outputSummary = outputPreview;
+  }
+  return out;
+}
+function inspectEventsToPersistedInspectEvents(events, options) {
+  return events.map(
+    (event, index) => inspectEventToPersistedInspectEvent(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 parseIsoToMs(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 = parseIsoToMs(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);
+}
+function traceEventsToPersistedRunTrees(events) {
+  const persisted = traceEventsToPersistedInspectEvents(events);
+  return persistedInspectEventsToRunTrees(persisted);
+}
+function isRecord3(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function isNonEmptyStringArray(v) {
@@ -75,7 +812,7 @@ function validateRedact(redact) {
   }
   for (const r of redact) {
     if (typeof r === "string") continue;
-    if (!isRecord2(r)) {
+    if (!isRecord3(r)) {
       throw new Error("Invalid config: redact entries must be strings or objects");
     }
     if (typeof r.key !== "string" || r.key.trim() === "") {
@@ -94,7 +831,7 @@ function validateRedact(redact) {
   }
 }
 function validateMappings(mappings) {
-  if (!isRecord2(mappings)) {
+  if (!isRecord3(mappings)) {
     throw new Error("Invalid config: mappings must be an object");
   }
 }
@@ -144,7 +881,7 @@ async function loadLogIngestConfig(configPath) {
     const msg = e instanceof Error ? e.message : String(e);
     throw new Error(`Invalid JSON in config file: ${configPath} (${msg})`);
   }
-  if (!isRecord2(parsed)) {
+  if (!isRecord3(parsed)) {
     throw new Error("Invalid config: expected a JSON object at top-level");
   }
   const user = parsed;
@@ -181,7 +918,7 @@ async function loadLogIngestConfig(configPath) {
   }
   return mergeLogIngestConfig(DEFAULT_LOG_INGEST_CONFIG, user);
 }
-function isRecord3(v) {
+function isRecord4(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var JsonLogParser = class {
@@ -206,7 +943,7 @@ var JsonLogParser = class {
         });
         continue;
       }
-      if (!isRecord3(parsed)) {
+      if (!isRecord4(parsed)) {
         warnings.push({
           code: "MALFORMED_JSON",
           message: "JSON log line must be an object",
@@ -237,7 +974,7 @@ var JsonLogParser = class {
     return this.parseLines(lines, filePath);
   }
 };
-function isRecord4(v) {
+function isRecord5(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function findLastJsonObjectSubstring(line) {
@@ -313,7 +1050,7 @@ var Log4jsParser = class {
         });
         continue;
       }
-      if (!isRecord4(parsed)) {
+      if (!isRecord5(parsed)) {
         warnings.push({
           code: "UNSUPPORTED_LOG4JS_PAYLOAD",
           message: "Embedded JSON payload must be an object",
@@ -391,7 +1128,7 @@ var DEFAULT_REDACT_KEYS = [
   "secret",
   "email"
 ];
-function isRecord5(v) {
+function isRecord6(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function toKey(s) {
@@ -459,7 +1196,7 @@ var Redactor = class {
     if (Array.isArray(value)) {
       return value.map((v) => this.#redactNested(v));
     }
-    if (isRecord5(value)) {
+    if (isRecord6(value)) {
       const out = {};
       for (const [k, v] of Object.entries(value)) {
         out[k] = this.redactValue(k, v);
@@ -469,6 +1206,36 @@ var Redactor = class {
     return value;
   }
 };
+
+// node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (bytes < 0 || bytes > 1024) throw new RangeError("Wrong ID size");
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.webcrypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.webcrypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
+// packages/core/src/logs/normalizer.ts
 function isFiniteNumber(v) {
   return typeof v === "number" && Number.isFinite(v);
 }
@@ -603,7 +1370,7 @@ var EventNormalizer = class {
       attributes[k] = v;
     }
     const event = {
-      eventId: nanoid.nanoid(10),
+      eventId: nanoid(10),
       runId,
       ...parentId ? { parentId } : {},
       name,
@@ -649,86 +1416,6 @@ var EventNormalizer = class {
   }
 };
 
-// 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/logs/tree-renderer.ts
 function truncate(v, max) {
   if (v.length <= max) return v;
@@ -1068,10 +1755,10 @@ var FALLBACK_TRACE_DIR = path__default.default.join(
 );
 var MAX_NAME_LENGTH = 100;
 function createRunId() {
-  return `run_${nanoid.nanoid(10)}`;
+  return `run_${nanoid(10)}`;
 }
 function createStepId() {
-  return `step_${nanoid.nanoid(10)}`;
+  return `step_${nanoid(10)}`;
 }
 function formatDuration2(ms) {
   return formatDuration(ms);
@@ -1151,168 +1838,38 @@ function formatError(error) {
     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 truncateName(name, maxLength = MAX_NAME_LENGTH) {
-  if (typeof name !== "string" || name.trim() === "") {
-    return "unnamed";
-  }
-  const trimmed = name.trim();
-  if (trimmed.length <= maxLength) {
-    return trimmed;
-  }
-  const ellipsis = "...";
-  const head = Math.max(0, maxLength - ellipsis.length);
-  return `${trimmed.slice(0, head)}${ellipsis}`;
-}
-function warn(message, error) {
-  const base = `[AgentInspect] ${message}`;
-  if (error === void 0) {
-    console.warn(base);
-    return;
-  }
-  console.warn(`${base}: ${formatError(error).message}`);
-}
-var storage = new async_hooks.AsyncLocalStorage();
-function toPublicContext(ctx) {
-  return {
-    runId: ctx.runId,
-    runName: ctx.runName,
-    traceDir: ctx.traceDir,
-    silent: ctx.silent,
-    metadata: ctx.metadata
-  };
-}
-function invoke(fn) {
-  return new Promise((resolve, reject) => {
-    try {
-      Promise.resolve(fn()).then(resolve, reject);
-    } catch (e) {
-      reject(e);
-    }
-  });
-}
-function getCurrentContext() {
-  try {
-    const s = storage.getStore();
-    if (!s) return void 0;
-    return toPublicContext(s);
-  } catch {
-    return void 0;
-  }
-}
-function getCurrentRunId() {
-  try {
-    return storage.getStore()?.runId;
-  } catch {
-    return void 0;
-  }
-}
-function getCurrentRunName() {
-  try {
-    return storage.getStore()?.runName;
-  } catch {
-    return void 0;
-  }
-}
-function getCurrentStepId() {
-  try {
-    return storage.getStore()?.currentStepId;
-  } catch {
-    return void 0;
-  }
-}
-function getParentStepId() {
-  return getCurrentStepId();
-}
-function getCurrentDepth() {
-  try {
-    const d = storage.getStore()?.currentDepth;
-    return typeof d === "number" && Number.isFinite(d) ? d : 0;
-  } catch {
-    return 0;
-  }
-}
-function hasActiveContext() {
-  try {
-    return storage.getStore() !== void 0;
-  } catch {
-    return false;
+    return { message: String(error) };
   }
-}
-function getTraceDirFromContext() {
-  try {
-    return storage.getStore()?.traceDir;
-  } catch {
-    return void 0;
+  if (typeof error === "object") {
+    try {
+      return { message: JSON.stringify(error) };
+    } catch {
+      return { message: "Unknown error" };
+    }
   }
+  return { message: "Unknown error" };
 }
-function isSilentContext() {
-  try {
-    const s = storage.getStore();
-    return s ? s.silent : false;
-  } catch {
-    return false;
+function truncateName(name, maxLength = MAX_NAME_LENGTH) {
+  if (typeof name !== "string" || name.trim() === "") {
+    return "unnamed";
   }
-}
-function runWithContext(context, fn) {
-  const runtime = {
-    runId: context.runId,
-    runName: context.runName,
-    traceDir: context.traceDir,
-    silent: context.silent,
-    metadata: context.metadata,
-    currentDepth: 0
-  };
-  return new Promise((resolve, reject) => {
-    storage.run(runtime, () => {
-      try {
-        Promise.resolve(fn()).then(resolve, reject);
-      } catch (e) {
-        reject(e);
-      }
-    });
-  });
-}
-function runWithStepContext(stepId, fn) {
-  let parent;
-  try {
-    parent = storage.getStore();
-  } catch {
-    parent = void 0;
+  const trimmed = name.trim();
+  if (trimmed.length <= maxLength) {
+    return trimmed;
   }
-  if (!parent) {
-    return invoke(fn);
+  const ellipsis = "...";
+  const head = Math.max(0, maxLength - ellipsis.length);
+  return `${trimmed.slice(0, head)}${ellipsis}`;
+}
+function warn(message, error) {
+  const base = `[AgentInspect] ${message}`;
+  if (error === void 0) {
+    console.warn(base);
+    return;
   }
-  const derived = {
-    runId: parent.runId,
-    runName: parent.runName,
-    traceDir: parent.traceDir,
-    silent: parent.silent,
-    metadata: parent.metadata,
-    currentStepId: stepId,
-    currentDepth: parent.currentDepth + 1
-  };
-  return new Promise((resolve, reject) => {
-    storage.run(derived, () => {
-      try {
-        Promise.resolve(fn()).then(resolve, reject);
-      } catch (e) {
-        reject(e);
-      }
-    });
-  });
+  console.warn(`${base}: ${formatError(error).message}`);
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmptyString(value) {
@@ -1323,7 +1880,7 @@ function finiteNumber(value) {
 }
 function optionalErrorInfo(value) {
   if (value === void 0) return true;
-  if (!isRecord6(value)) return false;
+  if (!isRecord7(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;
@@ -1331,7 +1888,7 @@ function optionalErrorInfo(value) {
   return true;
 }
 function validateEvent(event) {
-  if (!isRecord6(event)) return false;
+  if (!isRecord7(event)) return false;
   if (event.schemaVersion !== "0.1") return false;
   if (!finiteNumber(event.timestamp)) return false;
   if (typeof event.event !== "string") return false;
@@ -1340,7 +1897,7 @@ function validateEvent(event) {
       if (!nonEmptyString(event.runId) || !nonEmptyString(event.name) || !finiteNumber(event.startTime)) {
         return false;
       }
-      if (event.metadata !== void 0 && !isRecord6(event.metadata)) {
+      if (event.metadata !== void 0 && !isRecord7(event.metadata)) {
         return false;
       }
       return true;
@@ -1355,7 +1912,7 @@ function validateEvent(event) {
       if (event.parentId !== void 0 && typeof event.parentId !== "string") {
         return false;
       }
-      if (event.metadata !== void 0 && !isRecord6(event.metadata)) {
+      if (event.metadata !== void 0 && !isRecord7(event.metadata)) {
         return false;
       }
       return true;
@@ -1393,12 +1950,20 @@ async function initializeTraceFile(runId, traceDir) {
     return void 0;
   }
 }
+function ensureEventWithinBounds(event) {
+  const line = serializeEvent(event);
+  if (line === "") return event;
+  const bytes = Buffer.byteLength(line, "utf8");
+  if (bytes <= DEFAULT_MAX_EVENT_BYTES) return event;
+  return prepareTraceEventForDisk(event, resolveTraceSafetyOptions());
+}
 async function writeTraceEvent(event, traceDir) {
-  if (!validateEvent(event)) {
+  const bounded = ensureEventWithinBounds(event);
+  if (!validateEvent(bounded)) {
     warn("Skipped invalid trace event (validation failed)");
     return;
   }
-  const line = serializeEvent(event);
+  const line = serializeEvent(bounded);
   if (line === "") {
     warn("Skipped trace event (serialization failed)");
     return;
@@ -1418,87 +1983,432 @@ async function writeTraceEvent(event, traceDir) {
   if (await tryAppend(traceDir)) {
     return;
   }
-  warn(`Failed to append trace event for run ${event.runId}`);
-  if (await tryAppend(FALLBACK_TRACE_DIR)) {
-    return;
+  warn(`Failed to append trace event for run ${event.runId}`);
+  if (await tryAppend(FALLBACK_TRACE_DIR)) {
+    return;
+  }
+  warn("Failed to append trace event to fallback directory");
+}
+async function readTraceFile(runId, traceDir) {
+  try {
+    const filePath = getTraceFilePath(runId, traceDir);
+    return await promises.readFile(filePath, "utf-8");
+  } catch (e) {
+    if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+      return void 0;
+    }
+    warn("Unexpected error reading trace file", e);
+    return void 0;
+  }
+}
+async function readTraceEvents(runId, traceDir) {
+  const out = [];
+  try {
+    const raw = await readTraceFile(runId, traceDir);
+    if (raw === void 0) {
+      return out;
+    }
+    const lines = raw.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === "") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        warn("Skipped invalid JSON line in trace file");
+        continue;
+      }
+      if (validateEvent(parsed)) {
+        out.push(parsed);
+      } else {
+        warn("Skipped invalid trace event line in trace file");
+      }
+    }
+  } catch (e) {
+    warn("Failed to read trace events", e);
+  }
+  return out;
+}
+async function listTraceFiles(traceDir) {
+  try {
+    const usable = path__default.default.resolve(traceDir);
+    const names = await promises.readdir(usable);
+    const jsonl = names.filter((n) => n.endsWith(".jsonl"));
+    const withStat = await Promise.all(
+      jsonl.map(async (name) => {
+        try {
+          const st = await promises.stat(path__default.default.join(usable, name));
+          return { name, mtime: st.mtimeMs };
+        } catch {
+          return { name, mtime: 0 };
+        }
+      })
+    );
+    withStat.sort((a, b) => {
+      if (b.mtime !== a.mtime) return b.mtime - a.mtime;
+      return a.name.localeCompare(b.name);
+    });
+    return withStat.map((x) => x.name);
+  } catch {
+    return [];
+  }
+}
+function getRunIdFromTraceFileName(fileName) {
+  try {
+    const base = path__default.default.basename(fileName);
+    if (!base.endsWith(".jsonl")) return void 0;
+    const id = base.slice(0, -".jsonl".length);
+    return id === "" ? void 0 : id;
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/core/src/trace-event-safety.ts
+var DEFAULT_MAX_METADATA_VALUE_LENGTH = 2e3;
+var DEFAULT_MAX_PREVIEW_LENGTH = 500;
+var DEFAULT_MAX_EVENT_BYTES = 65536;
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPreviewKey(key) {
+  return key.toLowerCase().includes("preview");
+}
+function truncateString(value, maxLen) {
+  if (maxLen <= 0) return "\u2026";
+  if (value.length <= maxLen) return value;
+  return `${value.slice(0, maxLen)}\u2026`;
+}
+function byteLength(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+function resolveTraceSafetyOptions(options) {
+  const redact = options?.redact;
+  let redactEnabled = true;
+  let redactionRules;
+  if (redact === false) {
+    redactEnabled = false;
+  } else if (redact === true || redact === void 0) {
+    redactEnabled = true;
+  } else if (isRecord8(redact)) {
+    redactEnabled = true;
+    redactionRules = redact.rules;
+  }
+  return {
+    redactEnabled,
+    redactionRules,
+    maxMetadataValueLength: typeof options?.maxMetadataValueLength === "number" && Number.isFinite(options.maxMetadataValueLength) && options.maxMetadataValueLength >= 0 ? Math.floor(options.maxMetadataValueLength) : DEFAULT_MAX_METADATA_VALUE_LENGTH,
+    maxPreviewLength: typeof options?.maxPreviewLength === "number" && Number.isFinite(options.maxPreviewLength) && options.maxPreviewLength >= 0 ? Math.floor(options.maxPreviewLength) : DEFAULT_MAX_PREVIEW_LENGTH,
+    maxEventBytes: typeof options?.maxEventBytes === "number" && Number.isFinite(options.maxEventBytes) && options.maxEventBytes > 0 ? Math.floor(options.maxEventBytes) : DEFAULT_MAX_EVENT_BYTES
+  };
+}
+function boundMetadataValue(key, value, opts, seen, depth) {
+  if (depth > 32) return "[MaxDepth]";
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "string") {
+      const max = isPreviewKey(key) ? opts.maxPreviewLength : opts.maxMetadataValueLength;
+      return truncateString(value, max);
+    }
+    return value;
+  }
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const maxItems = 50;
+    const out2 = value.slice(0, maxItems).map(
+      (item, index) => boundMetadataValue(String(index), item, opts, seen, depth + 1)
+    );
+    if (value.length > maxItems) {
+      out2.push(`\u2026(+${value.length - maxItems} more)`);
+    }
+    return out2;
+  }
+  const record = value;
+  const out = {};
+  for (const [k, v] of Object.entries(record)) {
+    out[k] = boundMetadataValue(k, v, opts, seen, depth + 1);
+  }
+  return out;
+}
+function redactMetadata(metadata, opts) {
+  if (!opts.redactEnabled) return { ...metadata };
+  const redactor = new Redactor({ rules: opts.redactionRules });
+  return redactor.redactRecord(metadata);
+}
+function prepareMetadataForDisk(metadata, opts) {
+  try {
+    const redacted = redactMetadata(metadata, opts);
+    const seen = /* @__PURE__ */ new WeakSet();
+    const bounded = boundMetadataValue(
+      "metadata",
+      redacted,
+      opts,
+      seen,
+      0
+    );
+    return isRecord8(bounded) ? bounded : {};
+  } catch {
+    return { truncated: true, reason: "metadataPreparationFailed" };
+  }
+}
+function truncateErrorStack(event, maxLen) {
+  if (event.event !== "run_completed" && event.event !== "step_completed") {
+    return event;
+  }
+  if (!event.error?.stack || typeof event.error.stack !== "string") {
+    return event;
+  }
+  return {
+    ...event,
+    error: {
+      ...event.error,
+      stack: truncateString(event.error.stack, maxLen)
+    }
+  };
+}
+function replaceMetadataWithTruncationMarker(event, originalApproxBytes) {
+  const marker = {
+    truncated: true,
+    reason: "maxEventBytes",
+    originalApproxBytes
+  };
+  if (event.event === "run_started") {
+    return { ...event, metadata: marker };
+  }
+  if (event.event === "step_started") {
+    return { ...event, metadata: marker };
+  }
+  return event;
+}
+function shrinkMetadataLimits(opts, factor) {
+  return {
+    ...opts,
+    maxMetadataValueLength: Math.max(32, Math.floor(opts.maxMetadataValueLength * factor)),
+    maxPreviewLength: Math.max(16, Math.floor(opts.maxPreviewLength * factor))
+  };
+}
+function applyMetadataToEvent(event, metadata) {
+  if (event.event === "run_started") {
+    return { ...event, metadata };
+  }
+  if (event.event === "step_started") {
+    return { ...event, metadata };
+  }
+  return event;
+}
+function eventHasMetadata(event) {
+  return (event.event === "run_started" || event.event === "step_started") && event.metadata !== void 0;
+}
+function getEventMetadata(event) {
+  if (event.event === "run_started" || event.event === "step_started") {
+    return event.metadata;
+  }
+  return void 0;
+}
+function prepareTraceEventForDisk(event, opts) {
+  try {
+    let working = { ...event };
+    const rawMetadata = getEventMetadata(working);
+    if (rawMetadata !== void 0) {
+      const safe = prepareMetadataForDisk(rawMetadata, opts);
+      working = applyMetadataToEvent(working, safe);
+    }
+    let serialized = serializeEvent(working);
+    if (serialized === "") {
+      return working;
+    }
+    let bytes = byteLength(serialized);
+    if (bytes <= opts.maxEventBytes) {
+      return working;
+    }
+    if (rawMetadata !== void 0) {
+      for (const factor of [0.5, 0.25, 0.1]) {
+        const tighter = shrinkMetadataLimits(opts, factor);
+        const shrunk = prepareMetadataForDisk(rawMetadata, tighter);
+        working = applyMetadataToEvent(working, shrunk);
+        serialized = serializeEvent(working);
+        if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+          return working;
+        }
+      }
+      working = replaceMetadataWithTruncationMarker(working, bytes);
+      serialized = serializeEvent(working);
+      if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+        return working;
+      }
+    }
+    working = truncateErrorStack(working, Math.min(opts.maxMetadataValueLength, 500));
+    serialized = serializeEvent(working);
+    if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+      return working;
+    }
+    if (eventHasMetadata(working)) {
+      working = replaceMetadataWithTruncationMarker(working, bytes);
+      serialized = serializeEvent(working);
+      if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+        return working;
+      }
+      if (working.event === "run_started") {
+        const { metadata: _meta, ...rest } = working;
+        working = rest;
+      } else if (working.event === "step_started") {
+        const { metadata: _meta, ...rest } = working;
+        working = rest;
+      }
+    }
+    return working;
+  } catch {
+    if (event.event === "run_started" || event.event === "step_started") {
+      return applyMetadataToEvent(event, {
+        truncated: true,
+        reason: "prepareTraceEventFailed"
+      });
+    }
+    return event;
+  }
+}
+
+// packages/core/src/context.ts
+var storage = new async_hooks.AsyncLocalStorage();
+function toPublicContext(ctx) {
+  return {
+    runId: ctx.runId,
+    runName: ctx.runName,
+    traceDir: ctx.traceDir,
+    silent: ctx.silent,
+    metadata: ctx.metadata
+  };
+}
+function invoke(fn) {
+  return new Promise((resolve, reject) => {
+    try {
+      Promise.resolve(fn()).then(resolve, reject);
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+function getCurrentContext() {
+  try {
+    const s = storage.getStore();
+    if (!s) return void 0;
+    return toPublicContext(s);
+  } catch {
+    return void 0;
+  }
+}
+function getCurrentRunId() {
+  try {
+    return storage.getStore()?.runId;
+  } catch {
+    return void 0;
+  }
+}
+function getCurrentRunName() {
+  try {
+    return storage.getStore()?.runName;
+  } catch {
+    return void 0;
   }
-  warn("Failed to append trace event to fallback directory");
 }
-async function readTraceFile(runId, traceDir) {
+function getCurrentStepId() {
   try {
-    const filePath = getTraceFilePath(runId, traceDir);
-    return await promises.readFile(filePath, "utf-8");
-  } catch (e) {
-    if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
-      return void 0;
-    }
-    warn("Unexpected error reading trace file", e);
+    return storage.getStore()?.currentStepId;
+  } catch {
     return void 0;
   }
 }
-async function readTraceEvents(runId, traceDir) {
-  const out = [];
+function getParentStepId() {
+  return getCurrentStepId();
+}
+function getCurrentDepth() {
   try {
-    const raw = await readTraceFile(runId, traceDir);
-    if (raw === void 0) {
-      return out;
-    }
-    const lines = raw.split("\n");
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed === "") continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(trimmed);
-      } catch {
-        warn("Skipped invalid JSON line in trace file");
-        continue;
-      }
-      if (validateEvent(parsed)) {
-        out.push(parsed);
-      } else {
-        warn("Skipped invalid trace event line in trace file");
-      }
-    }
-  } catch (e) {
-    warn("Failed to read trace events", e);
+    const d = storage.getStore()?.currentDepth;
+    return typeof d === "number" && Number.isFinite(d) ? d : 0;
+  } catch {
+    return 0;
   }
-  return out;
 }
-async function listTraceFiles(traceDir) {
+function hasActiveContext() {
   try {
-    const usable = path__default.default.resolve(traceDir);
-    const names = await promises.readdir(usable);
-    const jsonl = names.filter((n) => n.endsWith(".jsonl"));
-    const withStat = await Promise.all(
-      jsonl.map(async (name) => {
-        try {
-          const st = await promises.stat(path__default.default.join(usable, name));
-          return { name, mtime: st.mtimeMs };
-        } catch {
-          return { name, mtime: 0 };
-        }
-      })
-    );
-    withStat.sort((a, b) => {
-      if (b.mtime !== a.mtime) return b.mtime - a.mtime;
-      return a.name.localeCompare(b.name);
-    });
-    return withStat.map((x) => x.name);
+    return storage.getStore() !== void 0;
   } catch {
-    return [];
+    return false;
   }
 }
-function getRunIdFromTraceFileName(fileName) {
+function getTraceDirFromContext() {
   try {
-    const base = path__default.default.basename(fileName);
-    if (!base.endsWith(".jsonl")) return void 0;
-    const id = base.slice(0, -".jsonl".length);
-    return id === "" ? void 0 : id;
+    return storage.getStore()?.traceDir;
+  } catch {
+    return void 0;
+  }
+}
+function isSilentContext() {
+  try {
+    const s = storage.getStore();
+    return s ? s.silent : false;
+  } catch {
+    return false;
+  }
+}
+function getTraceSafetyFromContext() {
+  try {
+    return storage.getStore()?.traceSafety;
   } catch {
     return void 0;
   }
 }
+function runWithContext(context, fn, traceSafety = resolveTraceSafetyOptions()) {
+  const runtime = {
+    runId: context.runId,
+    runName: context.runName,
+    traceDir: context.traceDir,
+    silent: context.silent,
+    metadata: context.metadata,
+    traceSafety,
+    currentDepth: 0
+  };
+  return new Promise((resolve, reject) => {
+    storage.run(runtime, () => {
+      try {
+        Promise.resolve(fn()).then(resolve, reject);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
+function runWithStepContext(stepId, fn) {
+  let parent;
+  try {
+    parent = storage.getStore();
+  } catch {
+    parent = void 0;
+  }
+  if (!parent) {
+    return invoke(fn);
+  }
+  const derived = {
+    runId: parent.runId,
+    runName: parent.runName,
+    traceDir: parent.traceDir,
+    silent: parent.silent,
+    metadata: parent.metadata,
+    traceSafety: parent.traceSafety,
+    currentStepId: stepId,
+    currentDepth: parent.currentDepth + 1
+  };
+  return new Promise((resolve, reject) => {
+    storage.run(derived, () => {
+      try {
+        Promise.resolve(fn()).then(resolve, reject);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
 function resolveTraceDir(options = {}) {
   if (typeof options.dir === "string" && options.dir.trim() !== "") {
     return options.dir.trim();
@@ -1763,7 +2673,7 @@ var KNOWN_EVENTS = /* @__PURE__ */ new Set([
   "step_started",
   "step_completed"
 ]);
-function isRecord7(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function safeParse(line) {
@@ -1785,7 +2695,7 @@ async function isAgentInspectTrace(filePath) {
       if (trimmed === "") continue;
       const parsed = safeParse(trimmed);
       if (!parsed) continue;
-      if (!isRecord7(parsed)) continue;
+      if (!isRecord9(parsed)) continue;
       checked += 1;
       if (isTraceEvent(parsed)) return true;
       const ev = parsed.event;
@@ -1948,7 +2858,7 @@ function stableJson(value, pretty) {
   const sorted = sortKeysDeep(value);
   return pretty === true ? JSON.stringify(sorted, null, 2) : JSON.stringify(sorted);
 }
-function compactAttributes(attrs, options) {
+function compactAttributes4(attrs, options) {
   if (attrs === void 0) return {};
   const maxLen = options?.maxLength ?? 500;
   const redacted = options?.redacted ?? true;
@@ -2303,6 +3213,498 @@ function diffRuns(left, right, options) {
   };
   return { summary, differences };
 }
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2__default.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process2__default.default;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2__default.default.platform === "win32") {
+    const osRelease = os__default.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty__default.default.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty__default.default.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// packages/core/src/diff/renderer.ts
 function formatPath(path5) {
   if (path5 === void 0 || path5.path.length === 0) {
     return "(run)";
@@ -2326,9 +3728,9 @@ function renderRunDiff(result, options) {
   }
   const sev = (s, level) => {
     if (!color) return s;
-    if (level === "error") return chalk2__default.default.red(s);
-    if (level === "warning") return chalk2__default.default.yellow(s);
-    return chalk2__default.default.gray(s);
+    if (level === "error") return source_default.red(s);
+    if (level === "warning") return source_default.yellow(s);
+    return source_default.gray(s);
   };
   const lines = [];
   const { summary } = result;
@@ -2391,6 +3793,8 @@ function diffTraceEvents(leftEvents, rightEvents, options) {
   const right = manualTraceEventsToComparableRun(rightEvents);
   return diffRuns(left, right, options);
 }
+
+// packages/core/src/terminal.ts
 var TERMINAL_INDENT = "  ";
 var MAX_TERMINAL_NAME_LENGTH = 80;
 var MAX_TERMINAL_DEPTH = 10;
@@ -2416,24 +3820,24 @@ function formatTerminalName(name) {
   return truncateName(name, MAX_TERMINAL_NAME_LENGTH);
 }
 function getStatusIcon(status) {
-  if (status === "success") return chalk2__default.default.green("\u2714");
-  if (status === "error") return chalk2__default.default.red("\u2716");
-  return chalk2__default.default.yellow("\u23F3");
+  if (status === "success") return source_default.green("\u2714");
+  if (status === "error") return source_default.red("\u2716");
+  return source_default.yellow("\u23F3");
 }
 function renderStepLine(name, durationMs, status, depth) {
   try {
     const nm = formatTerminalName(name);
     const ind = getIndent(depth ?? 0);
     if (status === "running" && durationMs === void 0) {
-      return `${ind}${chalk2__default.default.yellow("\u23F3")} ${nm}`;
+      return `${ind}${source_default.yellow("\u23F3")} ${nm}`;
     }
     const hasDur = durationMs !== void 0 && Number.isFinite(durationMs);
     const dur = hasDur ? formatDuration2(durationMs) : void 0;
     if (status === "running") {
-      return dur !== void 0 ? `${ind}${chalk2__default.default.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${chalk2__default.default.yellow("\u23F3")} ${nm}`;
+      return dur !== void 0 ? `${ind}${source_default.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${source_default.yellow("\u23F3")} ${nm}`;
     }
     if (!hasDur || dur === void 0) {
-      return `${ind}${chalk2__default.default.yellow("\u23F3")} ${nm}`;
+      return `${ind}${source_default.yellow("\u23F3")} ${nm}`;
     }
     if (status === "success") {
       return `${ind}${getStatusIcon("success")} ${nm} (${dur})`;
@@ -2469,7 +3873,7 @@ function printRunStart(runId, name) {
   if (isSilentContext()) return;
   try {
     safePrint("");
-    const header = `${chalk2__default.default.cyan.bold("\u{1F50D} AgentInspect:")} ${formatTerminalName(name)} ${chalk2__default.default.dim(`(${runId})`)}`;
+    const header = `${source_default.cyan.bold("\u{1F50D} AgentInspect:")} ${formatTerminalName(name)} ${source_default.dim(`(${runId})`)}`;
     safePrint(header);
   } catch {
   }
@@ -2502,10 +3906,10 @@ function printRunComplete(_name, _runId, durationMs, status, traceFilePath) {
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
       if (i === 0) {
-        const color = status === "error" ? chalk2__default.default.red : status === "running" ? chalk2__default.default.yellow : chalk2__default.default.green;
+        const color = status === "error" ? source_default.red : status === "running" ? source_default.yellow : source_default.green;
         safePrint(color(line));
       } else {
-        safePrint(chalk2__default.default.dim(line));
+        safePrint(source_default.dim(line));
       }
     }
   } catch {
@@ -2543,6 +3947,7 @@ async function inspectRun(name, fn, options) {
   const runName = normalizeRunName(name);
   const runId = createRunId();
   const traceDir = resolveTraceDir({ dir: options?.traceDir });
+  const traceSafety = resolveTraceSafetyOptions(options);
   const context = {
     runId,
     runName,
@@ -2566,7 +3971,10 @@ async function inspectRun(name, fn, options) {
         startTime,
         ...options?.metadata !== void 0 ? { metadata: options.metadata } : {}
       };
-      await writeTraceEvent(started, traceDir);
+      await writeTraceEvent(
+        prepareTraceEventForDisk(started, traceSafety),
+        traceDir
+      );
     });
     await safeInstrumentation("printRunStart", () => {
       printRunStart(runId, runName);
@@ -2590,7 +3998,10 @@ async function inspectRun(name, fn, options) {
           durationMs: durationMs2,
           error: formatted
         };
-        await writeTraceEvent(completed, traceDir);
+        await writeTraceEvent(
+          prepareTraceEventForDisk(completed, traceSafety),
+          traceDir
+        );
       });
       await safeInstrumentation("printRunComplete(error)", () => {
         printRunComplete(runName, runId, durationMs2, "error", printPath2);
@@ -2610,13 +4021,16 @@ async function inspectRun(name, fn, options) {
         endTime,
         durationMs
       };
-      await writeTraceEvent(completed, traceDir);
+      await writeTraceEvent(
+        prepareTraceEventForDisk(completed, traceSafety),
+        traceDir
+      );
     });
     await safeInstrumentation("printRunComplete(success)", () => {
       printRunComplete(runName, runId, durationMs, "success", printPath);
     });
     return result;
-  });
+  }, traceSafety);
 }
 
 // packages/core/src/maybe-inspect-run.ts
@@ -2667,6 +4081,7 @@ async function stepImpl(name, fn, options) {
   const parentId = getParentStepId();
   const stepType = options?.type ?? "logic";
   const metadata = options?.metadata;
+  const traceSafety = getTraceSafetyFromContext();
   const startTime = Date.now();
   await safeInstrumentation2("writeTraceEvent(step_started)", async () => {
     const started = {
@@ -2681,7 +4096,8 @@ async function stepImpl(name, fn, options) {
       startTime,
       ...metadata !== void 0 ? { metadata } : {}
     };
-    await writeTraceEvent(started, context.traceDir);
+    const safe = traceSafety !== void 0 ? prepareTraceEventForDisk(started, traceSafety) : started;
+    await writeTraceEvent(safe, context.traceDir);
   });
   await safeInstrumentation2("printStepStart", () => {
     printStepStart(stepName, renderDepth);
@@ -2707,7 +4123,8 @@ async function stepImpl(name, fn, options) {
         durationMs: durationMs2,
         error: formatted
       };
-      await writeTraceEvent(completed, context.traceDir);
+      const safe = traceSafety !== void 0 ? prepareTraceEventForDisk(completed, traceSafety) : completed;
+      await writeTraceEvent(safe, context.traceDir);
     });
     await safeInstrumentation2("printStepComplete(error)", () => {
       printStepComplete(stepName, durationMs2, "error", renderDepth);
@@ -2733,7 +4150,8 @@ async function stepImpl(name, fn, options) {
       endTime,
       durationMs
     };
-    await writeTraceEvent(completed, context.traceDir);
+    const safe = traceSafety !== void 0 ? prepareTraceEventForDisk(completed, traceSafety) : completed;
+    await writeTraceEvent(safe, context.traceDir);
   });
   await safeInstrumentation2("printStepComplete(success)", () => {
     printStepComplete(stepName, durationMs, "success", renderDepth);
@@ -2922,7 +4340,7 @@ function exportHtml(tree, options) {
     attrsHtml += "<h2>Attributes (bounded)</h2>";
     for (const n of flat) {
       if (!n.event.attributes || Object.keys(n.event.attributes).length === 0) continue;
-      const compact = compactAttributes(n.event.attributes, {
+      const compact = compactAttributes4(n.event.attributes, {
         maxLength: maxLen,
         redacted
       });
@@ -3073,7 +4491,7 @@ function exportMarkdown(tree, options) {
     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, {
+      const compact = compactAttributes4(n.event.attributes, {
         maxLength: maxLen,
         redacted
       });
@@ -3603,6 +5021,9 @@ function validateExport(result) {
 }
 
 exports.DEFAULT_LOG_INGEST_CONFIG = DEFAULT_LOG_INGEST_CONFIG;
+exports.DEFAULT_MAX_EVENT_BYTES = DEFAULT_MAX_EVENT_BYTES;
+exports.DEFAULT_MAX_METADATA_VALUE_LENGTH = DEFAULT_MAX_METADATA_VALUE_LENGTH;
+exports.DEFAULT_MAX_PREVIEW_LENGTH = DEFAULT_MAX_PREVIEW_LENGTH;
 exports.DEFAULT_REDACT_KEYS = DEFAULT_REDACT_KEYS;
 exports.DEFAULT_TRACE_DIR_NAME = DEFAULT_TRACE_DIR_NAME;
 exports.EXPORT_PAYLOAD_VERSION = EXPORT_PAYLOAD_VERSION;
@@ -3620,7 +5041,7 @@ exports.TERMINAL_INDENT = TERMINAL_INDENT;
 exports.TraceDirectory = TraceDirectory;
 exports.TreeBuilder = TreeBuilder;
 exports.buildRunSummary = buildRunSummary;
-exports.compactAttributes = compactAttributes;
+exports.compactAttributes = compactAttributes4;
 exports.createRunId = createRunId;
 exports.createStepId = createStepId;
 exports.diffRuns = diffRuns;
@@ -3651,11 +5072,15 @@ exports.getParentStepId = getParentStepId;
 exports.getRunIdFromTraceFileName = getRunIdFromTraceFileName;
 exports.getTraceDirFromContext = getTraceDirFromContext;
 exports.getTraceFilePath = getTraceFilePath;
+exports.getTraceSafetyFromContext = getTraceSafetyFromContext;
 exports.hasActiveContext = hasActiveContext;
 exports.initializeTraceFile = initializeTraceFile;
+exports.inspectEventToPersistedInspectEvent = inspectEventToPersistedInspectEvent;
+exports.inspectEventsToPersistedInspectEvents = inspectEventsToPersistedInspectEvents;
 exports.inspectRun = inspectRun;
 exports.isAgentInspectEnabled = isAgentInspectEnabled;
 exports.isAgentInspectTrace = isAgentInspectTrace;
+exports.isPersistedInspectEvent = isPersistedInspectEvent;
 exports.isSilentContext = isSilentContext;
 exports.isStepStatus = isStepStatus;
 exports.isStepType = isStepType;
@@ -3672,6 +5097,11 @@ exports.observe = observe;
 exports.parseDuration = parseDuration;
 exports.parseLogLine = parseLogLine;
 exports.parseLogsToTrees = parseLogsToTrees;
+exports.persistedInspectEventToInspectEvent = persistedInspectEventToInspectEvent;
+exports.persistedInspectEventsToInspectEvents = persistedInspectEventsToInspectEvents;
+exports.persistedInspectEventsToRunTrees = persistedInspectEventsToRunTrees;
+exports.prepareMetadataForDisk = prepareMetadataForDisk;
+exports.prepareTraceEventForDisk = prepareTraceEventForDisk;
 exports.printError = printError;
 exports.printFailedAt = printFailedAt;
 exports.printRunComplete = printRunComplete;
@@ -3687,6 +5117,7 @@ exports.renderRunTree = renderRunTree;
 exports.renderRunTrees = renderRunTrees;
 exports.renderStepLine = renderStepLine;
 exports.resolveTraceDir = resolveTraceDir;
+exports.resolveTraceSafetyOptions = resolveTraceSafetyOptions;
 exports.runWithContext = runWithContext;
 exports.runWithStepContext = runWithStepContext;
 exports.safeString = safeString2;
@@ -3694,6 +5125,9 @@ exports.serializeEvent = serializeEvent;
 exports.stableJson = stableJson;
 exports.step = step;
 exports.summarizeTree = summarizeTree;
+exports.traceEventToPersistedInspectEvent = traceEventToPersistedInspectEvent;
+exports.traceEventsToPersistedInspectEvents = traceEventsToPersistedInspectEvents;
+exports.traceEventsToPersistedRunTrees = traceEventsToPersistedRunTrees;
 exports.truncateName = truncateName;
 exports.validateEvent = validateEvent;
 exports.validateExport = validateExport;