agent-inspect 1.0.3 → 1.2.0

package/packages/core/dist/index.mjs

@@ -1,12 +1,12 @@
 import { readFile, mkdir, writeFile, readdir, stat, appendFile } from 'fs/promises';
-import crypto from 'crypto';
-import { nanoid } from 'nanoid';
+import crypto, { webcrypto } from 'crypto';
 import os from 'os';
 import path from 'path';
 import { AsyncLocalStorage } from 'async_hooks';
 import { createReadStream } from 'fs';
 import { createInterface } from 'readline';
-import chalk2 from 'chalk';
+import process2 from 'process';
+import tty from 'tty';
 
 // packages/core/src/types.ts
 var STEP_TYPES = [
@@ -54,7 +54,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) {
@@ -66,7 +802,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() === "") {
@@ -85,7 +821,7 @@ function validateRedact(redact) {
   }
 }
 function validateMappings(mappings) {
-  if (!isRecord2(mappings)) {
+  if (!isRecord3(mappings)) {
     throw new Error("Invalid config: mappings must be an object");
   }
 }
@@ -135,7 +871,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;
@@ -172,7 +908,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 {
@@ -197,7 +933,7 @@ var JsonLogParser = class {
         });
         continue;
       }
-      if (!isRecord3(parsed)) {
+      if (!isRecord4(parsed)) {
         warnings.push({
           code: "MALFORMED_JSON",
           message: "JSON log line must be an object",
@@ -228,7 +964,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) {
@@ -304,7 +1040,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",
@@ -382,7 +1118,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) {
@@ -450,7 +1186,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);
@@ -460,6 +1196,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);
+    webcrypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    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);
 }
@@ -640,86 +1406,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;
@@ -1142,168 +1828,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 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) {
@@ -1314,7 +1870,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;
@@ -1322,7 +1878,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;
@@ -1331,7 +1887,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;
@@ -1346,7 +1902,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;
@@ -1384,12 +1940,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;
@@ -1409,87 +1973,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 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.resolve(traceDir);
+    const names = await readdir(usable);
+    const jsonl = names.filter((n) => n.endsWith(".jsonl"));
+    const withStat = await Promise.all(
+      jsonl.map(async (name) => {
+        try {
+          const st = await stat(path.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.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 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 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.resolve(traceDir);
-    const names = await readdir(usable);
-    const jsonl = names.filter((n) => n.endsWith(".jsonl"));
-    const withStat = await Promise.all(
-      jsonl.map(async (name) => {
-        try {
-          const st = await stat(path.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.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();
@@ -1754,7 +2663,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) {
@@ -1776,7 +2685,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;
@@ -1939,7 +2848,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;
@@ -2294,6 +3203,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.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;
+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.platform === "win32") {
+    const osRelease = os.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.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.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)";
@@ -2317,9 +3718,9 @@ function renderRunDiff(result, options) {
   }
   const sev = (s, level) => {
     if (!color) return s;
-    if (level === "error") return chalk2.red(s);
-    if (level === "warning") return chalk2.yellow(s);
-    return chalk2.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;
@@ -2382,6 +3783,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;
@@ -2407,24 +3810,24 @@ function formatTerminalName(name) {
   return truncateName(name, MAX_TERMINAL_NAME_LENGTH);
 }
 function getStatusIcon(status) {
-  if (status === "success") return chalk2.green("\u2714");
-  if (status === "error") return chalk2.red("\u2716");
-  return chalk2.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.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.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${chalk2.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.yellow("\u23F3")} ${nm}`;
+      return `${ind}${source_default.yellow("\u23F3")} ${nm}`;
     }
     if (status === "success") {
       return `${ind}${getStatusIcon("success")} ${nm} (${dur})`;
@@ -2460,7 +3863,7 @@ function printRunStart(runId, name) {
   if (isSilentContext()) return;
   try {
     safePrint("");
-    const header = `${chalk2.cyan.bold("\u{1F50D} AgentInspect:")} ${formatTerminalName(name)} ${chalk2.dim(`(${runId})`)}`;
+    const header = `${source_default.cyan.bold("\u{1F50D} AgentInspect:")} ${formatTerminalName(name)} ${source_default.dim(`(${runId})`)}`;
     safePrint(header);
   } catch {
   }
@@ -2493,10 +3896,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.red : status === "running" ? chalk2.yellow : chalk2.green;
+        const color = status === "error" ? source_default.red : status === "running" ? source_default.yellow : source_default.green;
         safePrint(color(line));
       } else {
-        safePrint(chalk2.dim(line));
+        safePrint(source_default.dim(line));
       }
     }
   } catch {
@@ -2534,6 +3937,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,
@@ -2557,7 +3961,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);
@@ -2581,7 +3988,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);
@@ -2601,13 +4011,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
@@ -2658,6 +4071,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 = {
@@ -2672,7 +4086,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);
@@ -2698,7 +4113,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);
@@ -2724,7 +4140,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);
@@ -2913,7 +4330,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
       });
@@ -3064,7 +4481,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
       });
@@ -3593,6 +5010,6 @@ function validateExport(result) {
   };
 }
 
-export { DEFAULT_LOG_INGEST_CONFIG, DEFAULT_REDACT_KEYS, DEFAULT_TRACE_DIR_NAME, EXPORT_PAYLOAD_VERSION, EventNormalizer, FALLBACK_TRACE_DIR, JsonLogParser, LiveLogAccumulator, Log4jsParser, MAX_NAME_LENGTH, MAX_TERMINAL_DEPTH, MAX_TERMINAL_NAME_LENGTH, RUNS_DIR_NAME, Redactor, TERMINAL_INDENT, TraceDirectory, TreeBuilder, buildRunSummary, compactAttributes, createRunId, createStepId, diffRuns, diffTraceEvents, ensureTraceDir, escapeHtml, escapeMarkdown, exportHtml, exportMarkdown, exportOpenInference, exportOtlpJson, exportRunTree, extractMetadata, filterTraces, flattenTree, formatDuration2 as formatDuration, formatError, formatTerminalName, formatTimestamp, getCurrentContext, getCurrentDepth, getCurrentRunId, getCurrentRunName, getCurrentStepId, getDefaultTraceDir, getIndent, getParentStepId, getRunIdFromTraceFileName, getTraceDirFromContext, getTraceFilePath, hasActiveContext, initializeTraceFile, inspectRun, isAgentInspectEnabled, isAgentInspectTrace, isSilentContext, isStepStatus, isStepType, isTraceEvent, listTraceFiles, loadLogIngestConfig, manualTraceEventsToComparableRun, manualTraceEventsToRunTree, matchMapping, maybeInspectRun, mergeExportDefaults, mergeLogIngestConfig, observe, parseDuration, parseLogLine, parseLogsToTrees, printError, printFailedAt, printRunComplete, printRunStart, printStepComplete, printStepStart, readTraceEvents, readTraceFile, renderErrorLine, renderRunDiff, renderRunSummary, renderRunTree, renderRunTrees, renderStepLine, resolveTraceDir, runWithContext, runWithStepContext, safeString2 as safeString, serializeEvent, stableJson, step, summarizeTree, truncateName, validateEvent, validateExport, validateExportContent, warn, wildcardMatch, writeTraceEvent };
+export { DEFAULT_LOG_INGEST_CONFIG, DEFAULT_MAX_EVENT_BYTES, DEFAULT_MAX_METADATA_VALUE_LENGTH, DEFAULT_MAX_PREVIEW_LENGTH, DEFAULT_REDACT_KEYS, DEFAULT_TRACE_DIR_NAME, EXPORT_PAYLOAD_VERSION, EventNormalizer, FALLBACK_TRACE_DIR, JsonLogParser, LiveLogAccumulator, Log4jsParser, MAX_NAME_LENGTH, MAX_TERMINAL_DEPTH, MAX_TERMINAL_NAME_LENGTH, RUNS_DIR_NAME, Redactor, TERMINAL_INDENT, TraceDirectory, TreeBuilder, buildRunSummary, compactAttributes4 as compactAttributes, createRunId, createStepId, diffRuns, diffTraceEvents, ensureTraceDir, escapeHtml, escapeMarkdown, exportHtml, exportMarkdown, exportOpenInference, exportOtlpJson, exportRunTree, extractMetadata, filterTraces, flattenTree, formatDuration2 as formatDuration, formatError, formatTerminalName, formatTimestamp, getCurrentContext, getCurrentDepth, getCurrentRunId, getCurrentRunName, getCurrentStepId, getDefaultTraceDir, getIndent, getParentStepId, getRunIdFromTraceFileName, getTraceDirFromContext, getTraceFilePath, getTraceSafetyFromContext, hasActiveContext, initializeTraceFile, inspectEventToPersistedInspectEvent, inspectEventsToPersistedInspectEvents, inspectRun, isAgentInspectEnabled, isAgentInspectTrace, isPersistedInspectEvent, isSilentContext, isStepStatus, isStepType, isTraceEvent, listTraceFiles, loadLogIngestConfig, manualTraceEventsToComparableRun, manualTraceEventsToRunTree, matchMapping, maybeInspectRun, mergeExportDefaults, mergeLogIngestConfig, observe, parseDuration, parseLogLine, parseLogsToTrees, persistedInspectEventToInspectEvent, persistedInspectEventsToInspectEvents, persistedInspectEventsToRunTrees, prepareMetadataForDisk, prepareTraceEventForDisk, printError, printFailedAt, printRunComplete, printRunStart, printStepComplete, printStepStart, readTraceEvents, readTraceFile, renderErrorLine, renderRunDiff, renderRunSummary, renderRunTree, renderRunTrees, renderStepLine, resolveTraceDir, resolveTraceSafetyOptions, runWithContext, runWithStepContext, safeString2 as safeString, serializeEvent, stableJson, step, summarizeTree, traceEventToPersistedInspectEvent, traceEventsToPersistedInspectEvents, traceEventsToPersistedRunTrees, truncateName, validateEvent, validateExport, validateExportContent, warn, wildcardMatch, writeTraceEvent };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map