agent-inspect 0.1.1 → 1.0.0

package/packages/core/dist/index.cjs

@@ -1,17 +1,21 @@
 'use strict';
 
 var promises = require('fs/promises');
+var crypto = require('crypto');
+var nanoid = require('nanoid');
 var os = require('os');
 var path = require('path');
-var nanoid = require('nanoid');
 var async_hooks = require('async_hooks');
-var chalk = require('chalk');
+var fs = require('fs');
+var readline = require('readline');
+var chalk2 = require('chalk');
 
 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 chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var chalk2__default = /*#__PURE__*/_interopDefault(chalk2);
 
 // packages/core/src/types.ts
 var STEP_TYPES = [
@@ -59,6 +63,1002 @@ function isTraceEvent(value) {
       return false;
   }
 }
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isNonEmptyStringArray(v) {
+  return Array.isArray(v) && v.length > 0 && v.every((x) => typeof x === "string" && x.trim() !== "");
+}
+function validateRedact(redact) {
+  if (!Array.isArray(redact)) {
+    throw new Error("Invalid config: redact must be an array");
+  }
+  for (const r of redact) {
+    if (typeof r === "string") continue;
+    if (!isRecord2(r)) {
+      throw new Error("Invalid config: redact entries must be strings or objects");
+    }
+    if (typeof r.key !== "string" || r.key.trim() === "") {
+      throw new Error("Invalid config: redact.key must be a non-empty string");
+    }
+    if (r.strategy !== "full" && r.strategy !== "prefix" && r.strategy !== "hash") {
+      throw new Error(
+        `Invalid config: redact.strategy must be one of full, prefix, hash (got ${String(
+          r.strategy
+        )})`
+      );
+    }
+    if (r.keep !== void 0 && (typeof r.keep !== "number" || !Number.isFinite(r.keep) || r.keep < 0)) {
+      throw new Error("Invalid config: redact.keep must be a non-negative number when provided");
+    }
+  }
+}
+function validateMappings(mappings) {
+  if (!isRecord2(mappings)) {
+    throw new Error("Invalid config: mappings must be an object");
+  }
+}
+var DEFAULT_LOG_INGEST_CONFIG = {
+  runIdKeys: ["runId", "traceId", "requestId", "decisionId", "jobId"],
+  eventKey: "event",
+  timestampKey: "timestamp",
+  messageKey: "message",
+  levelKey: "level",
+  heuristicWindowMs: 2e3,
+  mappings: {
+    "*.error": { kind: "ERROR", status: "error" },
+    "*.failed": { kind: "ERROR", status: "error" },
+    "*.llm.*": { kind: "LLM" },
+    "*.tool.*": { kind: "TOOL" },
+    "*.agent.*": { kind: "AGENT" },
+    "*.retriever.*": { kind: "RETRIEVER" },
+    "*.result.*": { kind: "RESULT" }
+  }
+};
+function mergeLogIngestConfig(base, override) {
+  const merged = {
+    ...base,
+    ...override,
+    mappings: {
+      ...base.mappings ?? {},
+      ...override.mappings ?? {}
+    }
+  };
+  return merged;
+}
+async function loadLogIngestConfig(configPath) {
+  if (configPath === void 0 || configPath.trim() === "") {
+    return DEFAULT_LOG_INGEST_CONFIG;
+  }
+  let rawText;
+  try {
+    rawText = await promises.readFile(configPath, "utf-8");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`Failed to read config file: ${configPath} (${msg})`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawText);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`Invalid JSON in config file: ${configPath} (${msg})`);
+  }
+  if (!isRecord2(parsed)) {
+    throw new Error("Invalid config: expected a JSON object at top-level");
+  }
+  const user = parsed;
+  if (user.runIdKeys !== void 0 && !isNonEmptyStringArray(user.runIdKeys)) {
+    throw new Error("Invalid config: runIdKeys must be a non-empty array of strings");
+  }
+  if (user.eventKey !== void 0 && (typeof user.eventKey !== "string" || user.eventKey.trim() === "")) {
+    throw new Error("Invalid config: eventKey must be a non-empty string");
+  }
+  for (const k of [
+    "timestampKey",
+    "messageKey",
+    "levelKey",
+    "parentIdKey",
+    "durationKey",
+    "statusKey"
+  ]) {
+    const v = user[k];
+    if (v !== void 0 && (typeof v !== "string" || v.trim() === "")) {
+      throw new Error(`Invalid config: ${k} must be a non-empty string when provided`);
+    }
+  }
+  if (user.mappings !== void 0) {
+    validateMappings(user.mappings);
+  }
+  if (user.redact !== void 0) {
+    validateRedact(user.redact);
+  }
+  if (user.heuristicWindowMs !== void 0 && (typeof user.heuristicWindowMs !== "number" || !Number.isFinite(user.heuristicWindowMs) || user.heuristicWindowMs < 0)) {
+    throw new Error("Invalid config: heuristicWindowMs must be a non-negative number when provided");
+  }
+  if (user.redact && JSON.stringify(user.redact).includes("=>")) {
+    throw new Error("Invalid config: function strings are not supported in redact rules");
+  }
+  return mergeLogIngestConfig(DEFAULT_LOG_INGEST_CONFIG, user);
+}
+function isRecord3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var JsonLogParser = class {
+  parseLines(lines, filePath) {
+    const records = [];
+    const warnings = [];
+    for (let i = 0; i < lines.length; i++) {
+      const lineNumber = i + 1;
+      const raw = lines[i] ?? "";
+      const trimmed = raw.trim();
+      if (trimmed === "") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        warnings.push({
+          code: "MALFORMED_JSON",
+          message: "Malformed JSON log line",
+          file: filePath,
+          line: lineNumber,
+          raw: trimmed.slice(0, 500)
+        });
+        continue;
+      }
+      if (!isRecord3(parsed)) {
+        warnings.push({
+          code: "MALFORMED_JSON",
+          message: "JSON log line must be an object",
+          file: filePath,
+          line: lineNumber,
+          raw: trimmed.slice(0, 500)
+        });
+        continue;
+      }
+      records.push({
+        raw: parsed,
+        file: filePath,
+        line: lineNumber,
+        sourceType: "json-log"
+      });
+    }
+    return { records, warnings };
+  }
+  async parseFile(filePath) {
+    let text;
+    try {
+      text = await promises.readFile(filePath, "utf-8");
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new Error(`Failed to read log file: ${filePath} (${msg})`);
+    }
+    const lines = text.split(/\r?\n/);
+    return this.parseLines(lines, filePath);
+  }
+};
+function isRecord4(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function findLastJsonObjectSubstring(line) {
+  let last;
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] !== "{") continue;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let j = i; j < line.length; j++) {
+      const ch = line[j];
+      if (inString) {
+        if (escape) {
+          escape = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escape = true;
+          continue;
+        }
+        if (ch === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (ch === '"') {
+        inString = true;
+        continue;
+      }
+      if (ch === "{") depth += 1;
+      if (ch === "}") depth -= 1;
+      if (depth === 0) {
+        last = { start: i, end: j + 1 };
+        i = j;
+        break;
+      }
+      if (depth < 0) break;
+    }
+  }
+  if (!last) return void 0;
+  return line.slice(last.start, last.end);
+}
+var Log4jsParser = class {
+  parseLines(lines, filePath) {
+    const records = [];
+    const warnings = [];
+    for (let i = 0; i < lines.length; i++) {
+      const lineNumber = i + 1;
+      const rawLine = lines[i] ?? "";
+      const trimmed = rawLine.trim();
+      if (trimmed === "") continue;
+      const jsonText = findLastJsonObjectSubstring(trimmed);
+      if (!jsonText) {
+        warnings.push({
+          code: "UNSUPPORTED_LOG4JS_PAYLOAD",
+          message: "No embedded JSON object found in log4js line",
+          file: filePath,
+          line: lineNumber,
+          raw: trimmed.slice(0, 500)
+        });
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(jsonText);
+      } catch {
+        warnings.push({
+          code: "MALFORMED_JSON",
+          message: "Malformed embedded JSON object in log4js line",
+          file: filePath,
+          line: lineNumber,
+          raw: jsonText.slice(0, 500)
+        });
+        continue;
+      }
+      if (!isRecord4(parsed)) {
+        warnings.push({
+          code: "UNSUPPORTED_LOG4JS_PAYLOAD",
+          message: "Embedded JSON payload must be an object",
+          file: filePath,
+          line: lineNumber,
+          raw: jsonText.slice(0, 500)
+        });
+        continue;
+      }
+      records.push({
+        raw: parsed,
+        file: filePath,
+        line: lineNumber,
+        sourceType: "log4js"
+      });
+    }
+    return { records, warnings };
+  }
+  async parseFile(filePath) {
+    let text;
+    try {
+      text = await promises.readFile(filePath, "utf-8");
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new Error(`Failed to read log file: ${filePath} (${msg})`);
+    }
+    const lines = text.split(/\r?\n/);
+    return this.parseLines(lines, filePath);
+  }
+};
+
+// packages/core/src/logs/mapping.ts
+function wildcardMatch(pattern, value) {
+  if (pattern === value) return true;
+  if (!pattern.includes("*")) return false;
+  const parts = pattern.split("*");
+  let idx = 0;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "") continue;
+    const found = value.indexOf(part, idx);
+    if (found === -1) return false;
+    if (i === 0 && !pattern.startsWith("*") && found !== 0) return false;
+    idx = found + part.length;
+  }
+  if (!pattern.endsWith("*")) {
+    const last = parts[parts.length - 1];
+    if (last !== "" && !value.endsWith(last)) return false;
+    if (last === "" && !value.endsWith(parts[parts.length - 2] ?? "")) return false;
+  }
+  return true;
+}
+function matchMapping(eventName, mappings) {
+  if (!mappings) return void 0;
+  if (mappings[eventName]) return mappings[eventName];
+  let bestKey;
+  let bestScore = -1;
+  for (const key of Object.keys(mappings)) {
+    if (!key.includes("*")) continue;
+    if (!wildcardMatch(key, eventName)) continue;
+    const score = key.replaceAll("*", "").length;
+    if (score > bestScore) {
+      bestScore = score;
+      bestKey = key;
+    }
+  }
+  return bestKey ? mappings[bestKey] : void 0;
+}
+var DEFAULT_REDACT_KEYS = [
+  "authorization",
+  "cookie",
+  "token",
+  "apiKey",
+  "password",
+  "secret",
+  "email"
+];
+function isRecord5(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function toKey(s) {
+  return s.toLowerCase();
+}
+function stableHash(value) {
+  const h = crypto__default.default.createHash("sha256").update(value, "utf8").digest("hex");
+  return h.slice(0, 8);
+}
+function compileRules(rules) {
+  const out = /* @__PURE__ */ new Map();
+  const set = (r) => {
+    const k = toKey(r.key);
+    out.set(k, { ...r, key: k });
+  };
+  for (const k of DEFAULT_REDACT_KEYS) {
+    set({ key: k, strategy: "full" });
+  }
+  for (const r of rules ?? []) {
+    if (typeof r === "string") {
+      set({ key: r, strategy: "full" });
+      continue;
+    }
+    const key = r.key;
+    if (r.strategy === "full") set({ key, strategy: "full" });
+    if (r.strategy === "hash") set({ key, strategy: "hash" });
+    if (r.strategy === "prefix") {
+      set({ key, strategy: "prefix", keep: typeof r.keep === "number" ? r.keep : 8 });
+    }
+  }
+  return [...out.values()];
+}
+var Redactor = class {
+  #rules;
+  constructor(options) {
+    this.#rules = compileRules(options?.rules);
+  }
+  redactValue(key, value) {
+    const k = toKey(key);
+    const rule = this.#rules.find((r) => r.key === k);
+    if (!rule) {
+      return this.#redactNested(value);
+    }
+    if (rule.strategy === "full") return "[REDACTED]";
+    const asString = typeof value === "string" ? value : typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" ? String(value) : void 0;
+    if (rule.strategy === "prefix") {
+      if (asString === void 0) return "[REDACTED]";
+      const keep = Math.max(0, Math.floor(rule.keep));
+      return asString.length <= keep ? `${asString}\u2026` : `${asString.slice(0, keep)}\u2026`;
+    }
+    if (rule.strategy === "hash") {
+      if (asString === void 0) return "[HASH:unknown]";
+      return `[HASH:${stableHash(asString)}]`;
+    }
+    return this.#redactNested(value);
+  }
+  redactRecord(record) {
+    const out = {};
+    for (const [k, v] of Object.entries(record)) {
+      out[k] = this.redactValue(k, v);
+    }
+    return out;
+  }
+  #redactNested(value) {
+    if (Array.isArray(value)) {
+      return value.map((v) => this.#redactNested(v));
+    }
+    if (isRecord5(value)) {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = this.redactValue(k, v);
+      }
+      return out;
+    }
+    return value;
+  }
+};
+function isFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function safeString(v) {
+  if (typeof v !== "string") return void 0;
+  const t = v.trim();
+  return t === "" ? void 0 : t;
+}
+function parseTimestamp(v) {
+  if (isFiniteNumber(v)) return v;
+  if (typeof v === "string") {
+    const t = Date.parse(v);
+    if (Number.isFinite(t)) return t;
+  }
+  return void 0;
+}
+function hasToken(hay, token) {
+  return hay.includes(token);
+}
+function inferKind(eventName) {
+  if (hasToken(eventName, ".llm.")) return "LLM";
+  if (hasToken(eventName, ".tool.")) return "TOOL";
+  if (hasToken(eventName, ".agent.")) return "AGENT";
+  if (hasToken(eventName, ".retriever.")) return "RETRIEVER";
+  if (hasToken(eventName, ".result.")) return "RESULT";
+  if (eventName.endsWith(".error") || eventName.endsWith(".failed") || eventName.includes(".error") || eventName.includes(".failed")) {
+    return "ERROR";
+  }
+  return "LOG";
+}
+function deriveName(eventName, kind) {
+  const parts = eventName.split(".");
+  const last = parts[parts.length - 1] ?? eventName;
+  if (kind === "LLM") return `llm:${last}`;
+  if (kind === "TOOL") return `tool:${last}`;
+  if (kind === "AGENT") return `agent:${last}`;
+  if (kind === "RESULT") return `result:${last}`;
+  if (kind === "RUN") return `run:${last}`;
+  if (kind === "RETRIEVER") return `retriever:${last}`;
+  if (kind === "ERROR") return `error:${last}`;
+  return eventName;
+}
+var EventNormalizer = class {
+  #config;
+  constructor(options) {
+    this.#config = options.config;
+  }
+  #normalizeInternal(record) {
+    const raw = record.raw;
+    const cfg = this.#config;
+    let runId;
+    for (const k of cfg.runIdKeys) {
+      const v = raw[k];
+      const s = safeString(v);
+      if (s) {
+        runId = s;
+        break;
+      }
+    }
+    if (!runId) {
+      return {
+        warning: {
+          code: "MISSING_RUN_ID",
+          message: "Missing run id (none of runIdKeys present)",
+          file: record.file,
+          line: record.line
+        }
+      };
+    }
+    const eventName = safeString(raw[cfg.eventKey]);
+    if (!eventName) {
+      return {
+        warning: {
+          code: "MISSING_EVENT",
+          message: `Missing event name (key: ${cfg.eventKey})`,
+          file: record.file,
+          line: record.line
+        }
+      };
+    }
+    const mapping = matchMapping(eventName, cfg.mappings);
+    const tsKey = cfg.timestampKey ?? "timestamp";
+    const tsRaw = raw[tsKey];
+    const parsedTs = parseTimestamp(tsRaw);
+    const timestamp = parsedTs ?? Date.now();
+    const timestampMissing = parsedTs === void 0;
+    const parentIdKey = cfg.parentIdKey;
+    const parentId = parentIdKey ? safeString(raw[parentIdKey]) : void 0;
+    let durationMs;
+    const durationKey = cfg.durationKey;
+    if (durationKey) {
+      const v = raw[durationKey];
+      if (isFiniteNumber(v)) durationMs = v;
+    } else if (isFiniteNumber(raw.durationMs)) {
+      durationMs = raw.durationMs;
+    }
+    let status;
+    const statusKey = cfg.statusKey;
+    const statusRaw = statusKey ? safeString(raw[statusKey]) : void 0;
+    if (statusRaw === "running" || statusRaw === "ok" || statusRaw === "error") {
+      status = statusRaw;
+    } else if (mapping?.status) {
+      status = mapping.status;
+    } else if (mapping?.kind === "ERROR") {
+      status = "error";
+    } else if (eventName.includes(".failed") || eventName.includes(".error")) {
+      status = "error";
+    } else if (mapping?.startsRun || mapping?.startsStep) {
+      status = "running";
+    } else if (mapping?.endsRun || mapping?.endsStep) {
+      status = "ok";
+    }
+    const kind = mapping?.kind ?? inferKind(eventName);
+    const name = mapping?.name ?? deriveName(eventName, kind);
+    let confidence = "correlated";
+    if (parentId || mapping?.startsRun) confidence = "explicit";
+    if (timestampMissing) confidence = "unknown";
+    const omit = new Set([
+      ...cfg.runIdKeys,
+      cfg.eventKey,
+      tsKey,
+      cfg.messageKey ?? "message",
+      cfg.levelKey ?? "level",
+      cfg.parentIdKey ?? "",
+      cfg.durationKey ?? "",
+      cfg.statusKey ?? "",
+      "durationMs"
+    ].filter((k) => k !== ""));
+    const attributes = {};
+    for (const [k, v] of Object.entries(raw)) {
+      if (omit.has(k)) continue;
+      attributes[k] = v;
+    }
+    const event = {
+      eventId: nanoid.nanoid(10),
+      runId,
+      ...parentId ? { parentId } : {},
+      name,
+      kind,
+      timestamp,
+      ...status ? { status } : {},
+      ...durationMs !== void 0 ? { durationMs } : {},
+      ...Object.keys(attributes).length > 0 ? { attributes } : {},
+      confidence,
+      source: {
+        type: record.sourceType,
+        file: record.file,
+        line: record.line
+      }
+    };
+    if (timestampMissing) {
+      return {
+        event,
+        warning: {
+          code: "MISSING_TIMESTAMP",
+          message: `Missing or invalid timestamp (key: ${tsKey})`,
+          file: record.file,
+          line: record.line,
+          raw: JSON.stringify(raw).slice(0, 500)
+        }
+      };
+    }
+    return { event };
+  }
+  normalize(record) {
+    const r = this.#normalizeInternal(record);
+    return r.event ?? r.warning;
+  }
+  normalizeAll(records) {
+    const out = [];
+    const warnings = [];
+    for (const r of records) {
+      const normalized = this.#normalizeInternal(r);
+      if (normalized.event) out.push(normalized.event);
+      if (normalized.warning) warnings.push(normalized.warning);
+    }
+    return { records: out, warnings };
+  }
+};
+
+// 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;
+  return v.slice(0, Math.max(0, max - 1)) + "\u2026";
+}
+function fmtAttrValue(value, maxLen) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") return truncate(value, maxLen);
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "object") {
+    try {
+      return truncate(JSON.stringify(value), maxLen);
+    } catch {
+      return "[object]";
+    }
+  }
+  return String(value);
+}
+function compactAttrs(attrs, maxLen) {
+  if (!attrs) return "";
+  const entries = Object.entries(attrs);
+  if (entries.length === 0) return "";
+  const picks = /* @__PURE__ */ new Map();
+  const set = (k, v) => {
+    const s = fmtAttrValue(v, maxLen);
+    if (s !== void 0) picks.set(k, s);
+  };
+  set("job", attrs.jobId ?? attrs.job ?? attrs.jobUuid);
+  set("user", attrs.userUuid ?? attrs.userId ?? attrs.user);
+  set("trip", attrs.tripUuid ?? attrs.tripId ?? attrs.trip);
+  set("msgs", attrs.messageCount ?? attrs.msgs);
+  set("trips", attrs.trips);
+  set("model", attrs.model);
+  const tokens = attrs.tokens;
+  if (tokens && typeof tokens === "object" && tokens !== null) {
+    const input = tokens.input;
+    const output = tokens.output;
+    if (typeof input === "number" || typeof output === "number") {
+      picks.set("tokens", `${input ?? "?"}/${output ?? "?"}`);
+    }
+  }
+  for (const k of ["shouldNotify", "variant"]) {
+    if (k in attrs) set(k, attrs[k]);
+  }
+  const rendered = [...picks.entries()].filter(([, v]) => v !== "").map(([k, v]) => `${k}=${v}`);
+  return rendered.length > 0 ? " " + rendered.join(" ") : "";
+}
+function statusMark(node) {
+  if (node.event.status === "error") return " \u2716";
+  if (node.event.status === "ok") return " \u2714";
+  return "";
+}
+function fmtDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "";
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function renderNodeLines(node, prefix, isLast, options) {
+  const branch = prefix + (isLast ? "\u2514\u2500 " : "\u251C\u2500 ");
+  const nextPrefix = prefix + (isLast ? "   " : "\u2502  ");
+  const attrs = compactAttrs(node.event.attributes, options.maxAttributeLength);
+  const dur = node.event.durationMs !== void 0 ? ` ${fmtDuration(node.event.durationMs)}` : "";
+  const line = `${branch}${node.event.name}${attrs}${statusMark(node)}${dur}`;
+  const lines = [line];
+  const showConf = options.showConfidence === "always" || options.showConfidence === "non-explicit" && node.event.confidence !== "explicit";
+  if (showConf) {
+    lines.push(`${nextPrefix}confidence: ${node.event.confidence}`);
+  }
+  const children = node.children;
+  for (let i = 0; i < children.length; i++) {
+    lines.push(...renderNodeLines(children[i], nextPrefix, i === children.length - 1, options));
+  }
+  return lines;
+}
+function renderRunTree(tree, options) {
+  const opts = {
+    verbose: options?.verbose ?? false,
+    showConfidence: options?.showConfidence ?? "always",
+    showMetadata: options?.showMetadata ?? false,
+    color: options?.color ?? false,
+    maxAttributeLength: options?.maxAttributeLength ?? 40,
+    summary: options?.summary ?? true
+  };
+  const header = `Run ${tree.runId}`;
+  const lines = [header];
+  const children = tree.children;
+  for (let i = 0; i < children.length; i++) {
+    lines.push(...renderNodeLines(children[i], "", i === children.length - 1, opts));
+  }
+  if (opts.summary) {
+    const cb = tree.metadata.confidenceBreakdown;
+    const tools = tree.metadata.kinds.TOOL ?? 0;
+    const llms = tree.metadata.kinds.LLM ?? 0;
+    lines.push("");
+    lines.push("Summary:");
+    lines.push(`  Events: ${tree.metadata.totalEvents}`);
+    lines.push(`  Tools: ${tools}`);
+    lines.push(`  LLMs: ${llms}`);
+    lines.push(
+      `  Confidence: ${cb.explicit} explicit, ${cb.correlated} correlated, ${cb.heuristic} heuristic, ${cb.unknown} unknown`
+    );
+    lines.push("");
+    lines.push("Note:");
+    lines.push("  Flat timeline by default. Nesting only with explicit parentId.");
+  }
+  return lines.join("\n");
+}
+function renderRunTrees(trees, options) {
+  return trees.map((t) => renderRunTree(t, options)).join("\n\n");
+}
+
+// packages/core/src/logs/line-parser.ts
+function shiftLineNumbers(res, options) {
+  const targetLine = typeof options.line === "number" && Number.isFinite(options.line) && options.line > 0 ? Math.floor(options.line) : void 0;
+  const file = typeof options.file === "string" && options.file.trim() !== "" ? options.file : void 0;
+  if (targetLine === void 0 && file === void 0) return res;
+  const mapRecord = (x) => ({
+    ...x,
+    ...targetLine !== void 0 ? { line: targetLine } : {},
+    ...file !== void 0 ? { file } : {}
+  });
+  const mapWarning = (x) => ({
+    ...x,
+    ...targetLine !== void 0 ? { line: targetLine } : {},
+    ...file !== void 0 ? { file } : {}
+  });
+  return {
+    records: res.records.map(mapRecord),
+    warnings: res.warnings.map(mapWarning)
+  };
+}
+function normalizeFormat(line, format) {
+  if (format && format !== "auto") return format;
+  const trimmed = line.trim();
+  if (trimmed.startsWith("{")) return "json";
+  return "log4js";
+}
+function parseLogLine(line, options = {}) {
+  const raw = typeof line === "string" ? line : "";
+  const trimmed = raw.trim();
+  if (trimmed === "") return { records: [], warnings: [] };
+  const format = normalizeFormat(raw, options.format);
+  const base = format === "json" ? new JsonLogParser().parseLines([raw], options.file) : new Log4jsParser().parseLines([raw], options.file);
+  return shiftLineNumbers(base, options);
+}
+
+// packages/core/src/logs/live-tree.ts
+var LiveLogAccumulator = class {
+  #config;
+  #format;
+  #file;
+  #normalizer;
+  #redactor;
+  #treeBuilder;
+  #events = [];
+  #warnings = [];
+  #trees = [];
+  constructor(options) {
+    this.#config = mergeLogIngestConfig(options.config, {});
+    this.#format = options.format ?? "auto";
+    this.#file = options.file;
+    this.#normalizer = new EventNormalizer({ config: this.#config });
+    this.#redactor = new Redactor({ rules: this.#config.redact });
+    this.#treeBuilder = new TreeBuilder({ config: this.#config });
+  }
+  pushLine(line, lineNumber) {
+    try {
+      const parsed = parseLogLine(line, {
+        format: this.#format,
+        file: this.#file,
+        line: lineNumber
+      });
+      const normalized = this.#normalizer.normalizeAll(parsed.records);
+      const redactedEvents = normalized.records.map((e) => ({
+        ...e,
+        attributes: e.attributes ? this.#redactor.redactRecord(e.attributes) : void 0
+      }));
+      this.#events = [...this.#events, ...redactedEvents];
+      this.#warnings = [...this.#warnings, ...parsed.warnings, ...normalized.warnings];
+      this.#trees = this.#treeBuilder.build(this.#events);
+      return {
+        events: this.#events,
+        trees: this.#trees,
+        warnings: this.#warnings
+      };
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      const warning = {
+        code: "UNKNOWN",
+        message: `LiveLogAccumulator failed to process line (${msg})`,
+        file: this.#file,
+        line: lineNumber,
+        raw: typeof line === "string" ? line.slice(0, 500) : void 0
+      };
+      this.#warnings = [...this.#warnings, warning];
+      return { events: this.#events, trees: this.#trees, warnings: this.#warnings };
+    }
+  }
+  getEvents() {
+    return this.#events;
+  }
+  getTrees() {
+    return this.#trees;
+  }
+  getWarnings() {
+    return this.#warnings;
+  }
+  reset() {
+    this.#events = [];
+    this.#trees = [];
+    this.#warnings = [];
+  }
+};
+
+// packages/core/src/logs/index.ts
+function firstNonEmptyLine(text) {
+  for (const line of text.split(/\r?\n/)) {
+    const t = line.trim();
+    if (t !== "") return t;
+  }
+  return void 0;
+}
+async function detectFormat(filePath) {
+  const text = await promises.readFile(filePath, "utf-8");
+  const first = firstNonEmptyLine(text);
+  if (!first) return "log4js";
+  if (!first.startsWith("{")) return "log4js";
+  try {
+    const parsed = JSON.parse(first);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return "json";
+  } catch {
+  }
+  return "log4js";
+}
+function applyOverrides(cfg, options) {
+  const override = {};
+  for (const k of [
+    "runIdKeys",
+    "eventKey",
+    "timestampKey",
+    "messageKey",
+    "levelKey",
+    "parentIdKey",
+    "durationKey",
+    "statusKey"
+  ]) {
+    const v = options[k];
+    if (v !== void 0) override[k] = v;
+  }
+  return mergeLogIngestConfig(cfg, override);
+}
+async function parseLogsToTrees(filePath, options = {}) {
+  const base = options.config ?? await loadLogIngestConfig(options.configPath);
+  const config = applyOverrides(base, options);
+  const format = options.format === "auto" || options.format === void 0 ? await detectFormat(filePath) : options.format;
+  let parsed;
+  if (format === "json") {
+    parsed = await new JsonLogParser().parseFile(filePath);
+  } else {
+    parsed = await new Log4jsParser().parseFile(filePath);
+  }
+  const normalizer = new EventNormalizer({ config });
+  const normalized = normalizer.normalizeAll(parsed.records);
+  const redactor = new Redactor({ rules: config.redact });
+  const events = normalized.records.map((e) => ({
+    ...e,
+    attributes: e.attributes ? redactor.redactRecord(e.attributes) : void 0
+  }));
+  const trees = new TreeBuilder({ config }).build(events);
+  return {
+    events,
+    trees,
+    warnings: [...parsed.warnings, ...normalized.warnings]
+  };
+}
+
+// packages/core/src/utils/duration.ts
+function parseDuration(duration) {
+  const raw = typeof duration === "string" ? duration.trim() : "";
+  const match = raw.match(/^(\d+)(ms|[smhd])$/);
+  if (!match) {
+    throw new Error(
+      `Invalid duration format: ${duration}. Use a positive integer followed by ms, s, m, h, or d (e.g. 500ms, 30s, 5m, 2h, 7d).`
+    );
+  }
+  const amount = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  if (!Number.isFinite(amount) || amount <= 0) {
+    throw new Error(
+      `Invalid duration amount: ${duration}. Amount must be a positive integer.`
+    );
+  }
+  switch (unit) {
+    case "ms":
+      return amount;
+    case "s":
+      return amount * 1e3;
+    case "m":
+      return amount * 60 * 1e3;
+    case "h":
+      return amount * 60 * 60 * 1e3;
+    case "d":
+      return amount * 24 * 60 * 60 * 1e3;
+    default: {
+      throw new Error(`Unknown duration unit: ${unit}`);
+    }
+  }
+}
+function formatDuration(ms) {
+  if (!Number.isFinite(ms)) {
+    return "0ms";
+  }
+  if (ms < 0) {
+    throw new Error(`formatDuration: ms must be non-negative (got ${ms})`);
+  }
+  if (ms < 1e3) {
+    return `${Math.floor(ms)}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(2)}s`;
+  }
+  if (ms < 36e5) {
+    return `${(ms / 6e4).toFixed(1)}m`;
+  }
+  return `${(ms / 36e5).toFixed(1)}h`;
+}
+
+// packages/core/src/utils.ts
 var DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
 var RUNS_DIR_NAME = "runs";
 var FALLBACK_TRACE_DIR = path__default.default.join(
@@ -73,15 +1073,8 @@ function createRunId() {
 function createStepId() {
   return `step_${nanoid.nanoid(10)}`;
 }
-function formatDuration(ms) {
-  if (!Number.isFinite(ms) || ms < 0) {
-    return "0ms";
-  }
-  if (ms < 1e3) {
-    return `${Math.floor(ms)}ms`;
-  }
-  const seconds = ms / 1e3;
-  return `${(Math.round(seconds * 10) / 10).toFixed(1)}s`;
+function formatDuration2(ms) {
+  return formatDuration(ms);
 }
 function formatTimestamp(timestamp) {
   if (!Number.isFinite(timestamp)) {
@@ -100,6 +1093,10 @@ function formatTimestamp(timestamp) {
   return `${y}-${mo}-${day} ${h}:${min}:${s}`;
 }
 function getDefaultTraceDir() {
+  const envDir = process.env.AGENT_INSPECT_TRACE_DIR;
+  if (typeof envDir === "string" && envDir.trim() !== "") {
+    return envDir.trim();
+  }
   try {
     const home = os__default.default.homedir();
     if (typeof home !== "string" || home.trim() === "") {
@@ -315,7 +1312,7 @@ function runWithStepContext(stepId, fn) {
     });
   });
 }
-function isRecord2(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmptyString(value) {
@@ -326,7 +1323,7 @@ function finiteNumber(value) {
 }
 function optionalErrorInfo(value) {
   if (value === void 0) return true;
-  if (!isRecord2(value)) return false;
+  if (!isRecord6(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;
@@ -334,7 +1331,7 @@ function optionalErrorInfo(value) {
   return true;
 }
 function validateEvent(event) {
-  if (!isRecord2(event)) return false;
+  if (!isRecord6(event)) return false;
   if (event.schemaVersion !== "0.1") return false;
   if (!finiteNumber(event.timestamp)) return false;
   if (typeof event.event !== "string") return false;
@@ -343,7 +1340,7 @@ function validateEvent(event) {
       if (!nonEmptyString(event.runId) || !nonEmptyString(event.name) || !finiteNumber(event.startTime)) {
         return false;
       }
-      if (event.metadata !== void 0 && !isRecord2(event.metadata)) {
+      if (event.metadata !== void 0 && !isRecord6(event.metadata)) {
         return false;
       }
       return true;
@@ -358,7 +1355,7 @@ function validateEvent(event) {
       if (event.parentId !== void 0 && typeof event.parentId !== "string") {
         return false;
       }
-      if (event.metadata !== void 0 && !isRecord2(event.metadata)) {
+      if (event.metadata !== void 0 && !isRecord6(event.metadata)) {
         return false;
       }
       return true;
@@ -502,6 +1499,898 @@ function getRunIdFromTraceFileName(fileName) {
     return void 0;
   }
 }
+function resolveTraceDir(options = {}) {
+  if (typeof options.dir === "string" && options.dir.trim() !== "") {
+    return options.dir.trim();
+  }
+  const envDir = process.env.AGENT_INSPECT_TRACE_DIR;
+  if (typeof envDir === "string" && envDir.trim() !== "") {
+    return envDir.trim();
+  }
+  return getDefaultTraceDir();
+}
+var TraceDirectory = class {
+  #dir;
+  constructor(options = {}) {
+    this.#dir = resolveTraceDir(options);
+  }
+  getPath(filename) {
+    return filename ? path__default.default.join(this.#dir, filename) : this.#dir;
+  }
+  async list() {
+    try {
+      const files = await promises.readdir(this.#dir);
+      return files.filter((f) => f.endsWith(".jsonl"));
+    } catch (e) {
+      if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+        return [];
+      }
+      throw e;
+    }
+  }
+  async getFileStats(filename) {
+    return await promises.stat(this.getPath(filename));
+  }
+};
+function isFiniteNumber2(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function safeParseJson(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+}
+async function extractMetadata(filePath, _quickScan) {
+  const stats = await promises.stat(filePath);
+  let runIdFromFile = path__default.default.basename(filePath);
+  if (runIdFromFile.endsWith(".jsonl")) {
+    runIdFromFile = runIdFromFile.slice(0, -".jsonl".length);
+  }
+  const raw = await promises.readFile(filePath, "utf-8");
+  const lines = raw.split(/\r?\n/);
+  let eventCount = 0;
+  let runId;
+  let name;
+  let startedAt;
+  let endedAt;
+  let explicitDurationMs;
+  let hasRunStarted = false;
+  let hasRunCompleted = false;
+  let runCompletedStatus;
+  let anyStepError = false;
+  let anyKnownEvent = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    const parsed = safeParseJson(trimmed);
+    if (!parsed) continue;
+    if (!isTraceEvent(parsed)) continue;
+    const e = parsed;
+    anyKnownEvent = true;
+    eventCount += 1;
+    if (runId === void 0 && typeof e.runId === "string") {
+      runId = e.runId;
+    }
+    if (e.event === "run_started") {
+      hasRunStarted = true;
+      const rs = e;
+      if (typeof rs.name === "string" && rs.name.trim() !== "") {
+        name = rs.name;
+      }
+      if (isFiniteNumber2(rs.startTime)) {
+        startedAt = rs.startTime;
+      } else if (isFiniteNumber2(rs.timestamp)) {
+        startedAt = rs.timestamp;
+      }
+    }
+    if (e.event === "run_completed") {
+      hasRunCompleted = true;
+      const rc = e;
+      runCompletedStatus = rc.status;
+      if (isFiniteNumber2(rc.endTime)) endedAt = rc.endTime;
+      else if (isFiniteNumber2(rc.timestamp)) endedAt = rc.timestamp;
+      if (isFiniteNumber2(rc.durationMs)) explicitDurationMs = rc.durationMs;
+    }
+    if (e.event === "step_completed") {
+      const sc = e;
+      if (sc.status === "error") {
+        anyStepError = true;
+      }
+    }
+  }
+  const resolvedRunId = runId ?? runIdFromFile;
+  let status = "unknown";
+  if (hasRunCompleted && (runCompletedStatus === "success" || runCompletedStatus === "error")) {
+    status = runCompletedStatus;
+  } else if (anyStepError) {
+    status = "error";
+  } else if (hasRunStarted && !hasRunCompleted) {
+    status = "running";
+  } else if (anyKnownEvent) {
+    status = "unknown";
+  } else {
+    status = "unknown";
+  }
+  const durationMs = explicitDurationMs ?? (startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt ? endedAt - startedAt : void 0);
+  return {
+    runId: resolvedRunId,
+    name,
+    status,
+    startedAt,
+    endedAt,
+    durationMs,
+    eventCount,
+    filePath,
+    fileSize: stats.size,
+    createdAt: stats.birthtime
+  };
+}
+function buildRunSummary(events) {
+  const started = events.find(
+    (e) => e.event === "run_started"
+  );
+  const completed = events.filter(
+    (e) => e.event === "run_completed"
+  );
+  const lastCompleted = completed[completed.length - 1];
+  const runId = started?.runId ?? events.find((e) => typeof e.runId === "string")?.runId ?? "unknown-run";
+  const name = typeof started?.name === "string" && started.name.trim() !== "" ? started.name : void 0;
+  const status = lastCompleted ? lastCompleted.status : started ? "running" : "unknown";
+  const durationMs = lastCompleted && isFiniteNumber2(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  started && isFiniteNumber2(started.startTime) ? started.startTime : void 0;
+  const steps = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.event === "step_started") {
+      const s = e;
+      steps.set(s.stepId, {
+        type: s.type,
+        name: s.name,
+        status: "running",
+        parentId: s.parentId,
+        tokensInput: typeof s.metadata?.tokens?.input === "number" ? s.metadata.tokens.input : void 0,
+        tokensOutput: typeof s.metadata?.tokens?.output === "number" ? s.metadata.tokens.output : void 0
+      });
+    }
+  }
+  for (const e of events) {
+    if (e.event === "step_completed") {
+      const c = e;
+      const existing = steps.get(c.stepId);
+      if (!existing) continue;
+      existing.status = c.status;
+      existing.durationMs = c.durationMs;
+    }
+  }
+  let totalSteps = 0;
+  let llmSteps = 0;
+  let toolSteps = 0;
+  let logicSteps = 0;
+  let errorSteps = 0;
+  let maxDepth = 0;
+  let longestStep;
+  let totalTokensInput = 0;
+  let totalTokensOutput = 0;
+  let hasAnyTokens = false;
+  const depthCache = /* @__PURE__ */ new Map();
+  const computeDepth = (stepId) => {
+    const cached = depthCache.get(stepId);
+    if (cached !== void 0) return cached;
+    const node = steps.get(stepId);
+    if (!node) return 0;
+    const parent = node.parentId;
+    if (typeof parent !== "string" || parent.trim() === "" || !steps.has(parent)) {
+      depthCache.set(stepId, 0);
+      return 0;
+    }
+    const d = Math.min(1e3, computeDepth(parent) + 1);
+    depthCache.set(stepId, d);
+    return d;
+  };
+  for (const [id, s] of steps.entries()) {
+    totalSteps += 1;
+    if (s.type === "llm") llmSteps += 1;
+    else if (s.type === "tool") toolSteps += 1;
+    else logicSteps += 1;
+    if (s.status === "error") errorSteps += 1;
+    const depth = computeDepth(id);
+    if (depth > maxDepth) maxDepth = depth;
+    if (typeof s.durationMs === "number" && Number.isFinite(s.durationMs)) {
+      if (!longestStep || s.durationMs > longestStep.durationMs) {
+        longestStep = { name: s.name, durationMs: s.durationMs, type: s.type };
+      }
+    }
+    if (typeof s.tokensInput === "number" || typeof s.tokensOutput === "number") {
+      hasAnyTokens = true;
+      if (typeof s.tokensInput === "number") totalTokensInput += s.tokensInput;
+      if (typeof s.tokensOutput === "number") totalTokensOutput += s.tokensOutput;
+    }
+  }
+  const summary = {
+    runId,
+    name,
+    status,
+    durationMs,
+    totalSteps,
+    llmSteps,
+    toolSteps,
+    logicSteps,
+    errorSteps,
+    maxDepth,
+    ...longestStep ? { longestStep } : {},
+    ...hasAnyTokens ? { totalTokens: { input: totalTokensInput, output: totalTokensOutput } } : {}
+  };
+  return summary;
+}
+
+// packages/core/src/trace-filter.ts
+function toLower(s) {
+  return typeof s === "string" ? s.toLowerCase() : "";
+}
+function filterTraces(traces, options) {
+  const input = [...traces];
+  let out = input.filter((t) => {
+    if (options.status && t.status !== options.status) return false;
+    if (options.name) {
+      const q = options.name.toLowerCase();
+      const hay = `${toLower(t.name)} ${toLower(t.runId)}`;
+      if (!hay.includes(q)) return false;
+    }
+    if (options.since) {
+      const windowMs = parseDuration(options.since);
+      const cutoff = Date.now() - windowMs;
+      const started = typeof t.startedAt === "number" ? t.startedAt : void 0;
+      const basis = started ?? t.createdAt.getTime();
+      if (!Number.isFinite(basis) || basis < cutoff) return false;
+    }
+    return true;
+  });
+  out.sort((a, b) => {
+    const aTime = (typeof a.startedAt === "number" ? a.startedAt : void 0) ?? a.createdAt.getTime();
+    const bTime = (typeof b.startedAt === "number" ? b.startedAt : void 0) ?? b.createdAt.getTime();
+    return bTime - aTime;
+  });
+  if (typeof options.limit === "number" && Number.isFinite(options.limit)) {
+    const n = Math.max(0, Math.floor(options.limit));
+    out = out.slice(0, n);
+  }
+  return out;
+}
+var KNOWN_EVENTS = /* @__PURE__ */ new Set([
+  "run_started",
+  "run_completed",
+  "step_started",
+  "step_completed"
+]);
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function safeParse(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+}
+async function isAgentInspectTrace(filePath) {
+  try {
+    const rl = readline.createInterface({
+      input: fs.createReadStream(filePath, { encoding: "utf8" }),
+      crlfDelay: Infinity
+    });
+    let checked = 0;
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (trimmed === "") continue;
+      const parsed = safeParse(trimmed);
+      if (!parsed) continue;
+      if (!isRecord7(parsed)) continue;
+      checked += 1;
+      if (isTraceEvent(parsed)) return true;
+      const ev = parsed.event;
+      const runId = parsed.runId;
+      if (typeof ev === "string" && KNOWN_EVENTS.has(ev) && typeof runId === "string") {
+        return true;
+      }
+      if (checked >= 20) break;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// packages/core/src/diff/comparable.ts
+function extractOutputPreview(meta) {
+  if (meta === void 0) return void 0;
+  if ("outputPreview" in meta) return meta.outputPreview;
+  if ("resultPreview" in meta) return meta.resultPreview;
+  return void 0;
+}
+function mapStepStatus(s) {
+  if (s === void 0) return "running";
+  return s;
+}
+function manualTraceEventsToComparableRun(events) {
+  const started = events.find((e) => e.event === "run_started");
+  if (!started || started.event !== "run_started") {
+    throw new Error("Invalid trace: missing run_started");
+  }
+  const rs = started;
+  const runId = rs.runId;
+  const completedAll = events.filter((e) => e.event === "run_completed");
+  const lastCompleted = completedAll[completedAll.length - 1];
+  let runStatus;
+  if (lastCompleted === void 0) runStatus = "running";
+  else runStatus = lastCompleted.status;
+  const durationMs = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const steps = /* @__PURE__ */ new Map();
+  let order = 0;
+  for (const e of events) {
+    if (e.event !== "step_started") continue;
+    const s = e;
+    const meta = s.metadata ? { ...s.metadata } : void 0;
+    steps.set(s.stepId, {
+      id: s.stepId,
+      parentId: s.parentId,
+      name: s.name,
+      type: s.type,
+      order: order++,
+      timestamp: s.timestamp,
+      metadata: meta
+    });
+  }
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const acc = steps.get(e.stepId);
+    if (!acc) continue;
+    acc.status = e.status;
+    acc.durationMs = e.durationMs;
+    if (e.error?.message) acc.errorMsg = e.error.message;
+    const extra = e;
+    if (extra.metadata !== void 0 && typeof extra.metadata === "object") {
+      acc.metadata = { ...acc.metadata ?? {}, ...extra.metadata };
+    }
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  for (const acc of steps.values()) {
+    let meta = acc.metadata ? { ...acc.metadata } : void 0;
+    if (acc.parentId !== void 0 && !steps.has(acc.parentId)) {
+      meta = { ...meta ?? {}, agent_inspect_diff_parent_missing: true };
+    }
+    const outputPreview = extractOutputPreview(meta);
+    const sc = {
+      id: acc.id,
+      name: acc.name,
+      type: acc.type,
+      status: mapStepStatus(acc.status),
+      durationMs: acc.durationMs,
+      error: acc.errorMsg,
+      metadata: meta && Object.keys(meta).length > 0 ? meta : void 0,
+      outputPreview,
+      children: []
+    };
+    nodes.set(acc.id, sc);
+  }
+  const roots = [];
+  const sortByOrder = (a, b) => {
+    const oa = steps.get(a.id)?.order ?? 0;
+    const ob = steps.get(b.id)?.order ?? 0;
+    return oa - ob;
+  };
+  for (const acc of steps.values()) {
+    const node = nodes.get(acc.id);
+    if (acc.parentId !== void 0 && nodes.has(acc.parentId)) {
+      nodes.get(acc.parentId).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  roots.sort(sortByOrder);
+  for (const n of nodes.values()) {
+    n.children.sort(sortByOrder);
+  }
+  return {
+    runId,
+    name: rs.name,
+    status: runStatus,
+    durationMs,
+    steps: roots
+  };
+}
+
+// packages/core/src/exporters/helpers.ts
+var REDACT_SUBSTRINGS = [
+  "authorization",
+  "cookie",
+  "token",
+  "apikey",
+  "password",
+  "secret",
+  "email"
+];
+function shouldRedactKey(key) {
+  const k = key.toLowerCase();
+  for (const s of REDACT_SUBSTRINGS) {
+    if (k.includes(s)) return true;
+  }
+  return false;
+}
+function safeString2(value, maxLength) {
+  if (value === null || value === void 0) return "";
+  let s;
+  if (typeof value === "string") s = value;
+  else if (typeof value === "number" || typeof value === "boolean") s = String(value);
+  else s = stableJson(value, false);
+  if (maxLength !== void 0 && maxLength >= 0 && s.length > maxLength) {
+    return `${s.slice(0, maxLength)}\u2026`;
+  }
+  return s;
+}
+function escapeMarkdown(value) {
+  return value.replace(/\|/g, "\\|").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, " ");
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sortKeysDeep(input) {
+  if (input === null || typeof input !== "object") return input;
+  if (Array.isArray(input)) return input.map(sortKeysDeep);
+  const o = input;
+  const out = {};
+  for (const k of Object.keys(o).sort()) {
+    out[k] = sortKeysDeep(o[k]);
+  }
+  return out;
+}
+function stableJson(value, pretty) {
+  const sorted = sortKeysDeep(value);
+  return pretty === true ? JSON.stringify(sorted, null, 2) : JSON.stringify(sorted);
+}
+function compactAttributes(attrs, options) {
+  if (attrs === void 0) return {};
+  const maxLen = options?.maxLength ?? 500;
+  const redacted = options?.redacted ?? true;
+  const out = {};
+  for (const key of Object.keys(attrs).sort()) {
+    if (redacted && shouldRedactKey(key)) {
+      out[key] = "[REDACTED]";
+      continue;
+    }
+    const v = attrs[key];
+    out[key] = compactValue(v, maxLen, redacted);
+  }
+  return out;
+}
+function compactValue(value, maxLen, redacted) {
+  if (value === null || typeof value !== "object") {
+    return typeof value === "string" ? safeString2(value, maxLen) : value;
+  }
+  if (Array.isArray(value)) {
+    const arr = value.slice(0, 20).map((x) => compactValue(x, maxLen, redacted));
+    if (value.length > 20) arr.push(`\u2026(+${value.length - 20} more)`);
+    return arr;
+  }
+  const o = value;
+  const inner = {};
+  for (const k of Object.keys(o)) {
+    if (redacted && shouldRedactKey(k)) inner[k] = "[REDACTED]";
+    else inner[k] = compactValue(o[k], maxLen, redacted);
+  }
+  return inner;
+}
+function summarizeTree(tree) {
+  const flat = flattenTree(tree);
+  const errorNodes = flat.filter((n) => n.event.status === "error").length;
+  return {
+    runId: tree.runId,
+    name: tree.name,
+    status: tree.status,
+    startedAt: tree.startedAt,
+    endedAt: tree.endedAt,
+    durationMs: tree.durationMs,
+    stepCount: flat.length,
+    errorStepCount: errorNodes,
+    totalEvents: tree.metadata.totalEvents,
+    confidenceBreakdown: { ...tree.metadata.confidenceBreakdown },
+    kinds: { ...tree.metadata.kinds }
+  };
+}
+function flattenTree(tree) {
+  const out = [];
+  function walk(nodes) {
+    for (const n of nodes) {
+      out.push(n);
+      if (n.children.length > 0) walk(n.children);
+    }
+  }
+  walk(tree.children);
+  return out;
+}
+function zeroKinds() {
+  return {
+    RUN: 0,
+    AGENT: 0,
+    LLM: 0,
+    TOOL: 0,
+    CHAIN: 0,
+    RETRIEVER: 0,
+    DECISION: 0,
+    RESULT: 0,
+    ERROR: 0,
+    LOGIC: 0,
+    LOG: 0
+  };
+}
+
+// packages/core/src/diff/engine.ts
+var DEFAULT_THRESHOLD_MS = 0;
+function pathSeg(step2, index) {
+  return { index, name: step2.name, stepId: step2.id };
+}
+function buildPath(segments) {
+  return { path: [...segments] };
+}
+function pairSteps(left, right) {
+  const usedRight = /* @__PURE__ */ new Set();
+  const pairs = [];
+  for (let i = 0; i < left.length; i++) {
+    const L = left[i];
+    let R = right.find((r) => !usedRight.has(r.id) && r.id === L.id);
+    if (R === void 0 && i < right.length && !usedRight.has(right[i].id)) {
+      const cand = right[i];
+      if (cand.name === L.name && (cand.type ?? "") === (L.type ?? "")) {
+        R = cand;
+      }
+    }
+    if (R === void 0) {
+      R = right.find(
+        (r) => !usedRight.has(r.id) && r.name === L.name && (r.type ?? "") === (L.type ?? "")
+      );
+    }
+    if (R !== void 0) {
+      usedRight.add(R.id);
+      pairs.push([L, R]);
+    } else {
+      pairs.push([L, void 0]);
+    }
+  }
+  for (const R of right) {
+    if (!usedRight.has(R.id)) {
+      pairs.push([void 0, R]);
+    }
+  }
+  return pairs;
+}
+function compareLeafSteps(L, R, segments, opts, out) {
+  const path5 = buildPath(segments);
+  if (L.name !== R.name) {
+    out.push({
+      kind: "structure",
+      severity: "warning",
+      message: "Step name differs",
+      path: path5,
+      left: L.name,
+      right: R.name
+    });
+  }
+  if ((L.type ?? "") !== (R.type ?? "")) {
+    out.push({
+      kind: "step-type",
+      severity: "warning",
+      message: "Step type differs",
+      path: path5,
+      left: L.type,
+      right: R.type
+    });
+  }
+  if ((L.status ?? "") !== (R.status ?? "")) {
+    out.push({
+      kind: "step-status",
+      severity: "warning",
+      message: "Step status differs",
+      path: path5,
+      left: L.status,
+      right: R.status
+    });
+  }
+  const le = L.error ?? "";
+  const re = R.error ?? "";
+  if (le !== re) {
+    out.push({
+      kind: "error",
+      severity: "error",
+      message: "Step error message differs",
+      path: path5,
+      left: le || void 0,
+      right: re || void 0
+    });
+  }
+  if (!opts.ignoreDuration) {
+    const ld = L.durationMs;
+    const rd = R.durationMs;
+    const th = opts.durationThresholdMs;
+    let differs = false;
+    if (ld === void 0 && rd === void 0) differs = false;
+    else if (ld === void 0 || rd === void 0) differs = true;
+    else differs = Math.abs(ld - rd) > th;
+    if (differs) {
+      out.push({
+        kind: "duration",
+        severity: "info",
+        message: "Step duration differs",
+        path: path5,
+        left: ld,
+        right: rd
+      });
+    }
+  }
+  const lm = stableJson(L.metadata ?? {});
+  const rm = stableJson(R.metadata ?? {});
+  if (lm !== rm) {
+    out.push({
+      kind: "metadata",
+      severity: "info",
+      message: "Step metadata differs",
+      path: path5,
+      left: L.metadata,
+      right: R.metadata
+    });
+  }
+  const lo = stableJson(L.outputPreview ?? null);
+  const ro = stableJson(R.outputPreview ?? null);
+  if (lo !== ro) {
+    out.push({
+      kind: "output",
+      severity: "info",
+      message: "Output preview differs",
+      path: path5,
+      left: L.outputPreview,
+      right: R.outputPreview
+    });
+  }
+}
+function compareRecursive(L, R, segments, opts, out) {
+  compareLeafSteps(L, R, segments, opts, out);
+  const pairs = pairSteps(L.children, R.children);
+  let ci = 0;
+  for (const [lch, rch] of pairs) {
+    if (lch !== void 0 && rch !== void 0) {
+      compareRecursive(lch, rch, [...segments, pathSeg(lch, ci)], opts, out);
+    } else if (lch !== void 0) {
+      out.push({
+        kind: "step-removed",
+        severity: "warning",
+        message: `Step only in left run: ${lch.name}`,
+        path: buildPath([...segments, pathSeg(lch, ci)]),
+        left: lch.id,
+        right: void 0
+      });
+    } else if (rch !== void 0) {
+      out.push({
+        kind: "step-added",
+        severity: "warning",
+        message: `Step only in right run: ${rch.name}`,
+        path: buildPath([...segments, pathSeg(rch, ci)]),
+        left: void 0,
+        right: rch.id
+      });
+    }
+    ci += 1;
+  }
+}
+function mergeDiffDefaults(options) {
+  return {
+    ignoreDuration: options?.ignoreDuration ?? false,
+    durationThresholdMs: options?.durationThresholdMs !== void 0 ? options.durationThresholdMs : DEFAULT_THRESHOLD_MS,
+    focus: options?.focus ?? "all",
+    check: options?.check ?? "all"
+  };
+}
+function kindMatchesFilter(kind, merged) {
+  const { focus, check } = merged;
+  if (check !== "all") {
+    if (check === "structure") {
+      if (!["step-added", "step-removed", "structure", "step-type"].includes(kind)) return false;
+    } else if (check === "outputs") {
+      if (!["metadata", "output"].includes(kind)) return false;
+    } else if (check === "errors") {
+      if (!["run-status", "step-status", "error"].includes(kind)) return false;
+    } else if (check === "timing") {
+      if (kind !== "duration") return false;
+    }
+  }
+  if (focus !== "all") {
+    if (focus === "errors") {
+      if (!["run-status", "step-status", "error"].includes(kind)) return false;
+    } else if (focus === "structure") {
+      if (!["step-added", "step-removed", "structure", "step-type"].includes(kind)) return false;
+    } else if (focus === "outputs") {
+      if (!["metadata", "output"].includes(kind)) return false;
+    }
+  }
+  return true;
+}
+function diffRuns(left, right, options) {
+  const merged = mergeDiffDefaults(options);
+  const opts = {
+    ignoreDuration: merged.ignoreDuration,
+    durationThresholdMs: merged.durationThresholdMs
+  };
+  const raw = [];
+  if ((left.status ?? "") !== (right.status ?? "")) {
+    raw.push({
+      kind: "run-status",
+      severity: "warning",
+      message: "Run completion status differs",
+      left: left.status,
+      right: right.status
+    });
+  }
+  if (!merged.ignoreDuration) {
+    const ld = left.durationMs;
+    const rd = right.durationMs;
+    const th = merged.durationThresholdMs;
+    let differs = false;
+    if (ld === void 0 && rd === void 0) differs = false;
+    else if (ld === void 0 || rd === void 0) differs = true;
+    else differs = Math.abs(ld - rd) > th;
+    if (differs) {
+      raw.push({
+        kind: "duration",
+        severity: "info",
+        message: "Run duration differs",
+        left: ld,
+        right: rd
+      });
+    }
+  }
+  const pairs = pairSteps(left.steps, right.steps);
+  let idx = 0;
+  for (const [ls, rs] of pairs) {
+    if (ls !== void 0 && rs !== void 0) {
+      compareRecursive(ls, rs, [pathSeg(ls, idx)], opts, raw);
+      idx += 1;
+    } else if (ls !== void 0) {
+      raw.push({
+        kind: "step-removed",
+        severity: "warning",
+        message: `Step only in left run: ${ls.name}`,
+        path: buildPath([pathSeg(ls, idx)]),
+        left: ls.id,
+        right: void 0
+      });
+      idx += 1;
+    } else if (rs !== void 0) {
+      raw.push({
+        kind: "step-added",
+        severity: "warning",
+        message: `Step only in right run: ${rs.name}`,
+        path: buildPath([pathSeg(rs, idx)]),
+        left: void 0,
+        right: rs.id
+      });
+      idx += 1;
+    }
+  }
+  const differences = raw.filter((d) => kindMatchesFilter(d.kind, merged));
+  let errors = 0;
+  let warnings = 0;
+  let info = 0;
+  for (const d of differences) {
+    if (d.severity === "error") errors += 1;
+    else if (d.severity === "warning") warnings += 1;
+    else info += 1;
+  }
+  const firstVisible = differences[0];
+  const firstDivergence = firstVisible !== void 0 ? {
+    kind: "first-divergence",
+    severity: firstVisible.severity,
+    message: `First divergence: ${firstVisible.message}`,
+    path: firstVisible.path,
+    left: firstVisible.left,
+    right: firstVisible.right
+  } : void 0;
+  const summary = {
+    leftRunId: left.runId,
+    rightRunId: right.runId,
+    totalDifferences: differences.length,
+    errors,
+    warnings,
+    info,
+    firstDivergence
+  };
+  return { summary, differences };
+}
+function formatPath(path5) {
+  if (path5 === void 0 || path5.path.length === 0) {
+    return "(run)";
+  }
+  return path5.path.map((s) => s.name).join(" > ");
+}
+function formatValue(v, verbose) {
+  if (v === void 0) return "(undefined)";
+  if (typeof v === "string") return v;
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  const s = JSON.stringify(v);
+  if (verbose || s.length <= 120) return s;
+  return `${s.slice(0, 117)}...`;
+}
+function renderRunDiff(result, options) {
+  const json = options?.json === true;
+  const verbose = options?.verbose === true;
+  const color = options?.color === true;
+  if (json) {
+    return JSON.stringify(result, null, 2);
+  }
+  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);
+  };
+  const lines = [];
+  const { summary } = result;
+  lines.push("Run diff");
+  lines.push(`Left:  ${summary.leftRunId}`);
+  lines.push(`Right: ${summary.rightRunId}`);
+  lines.push("");
+  lines.push("Summary:");
+  lines.push(`  Differences: ${summary.totalDifferences}`);
+  lines.push(`  Errors: ${summary.errors}`);
+  lines.push(`  Warnings: ${summary.warnings}`);
+  lines.push(`  Info: ${summary.info}`);
+  lines.push("");
+  const fd = summary.firstDivergence;
+  const firstKind = result.differences[0]?.kind;
+  if (fd !== void 0) {
+    lines.push("First divergence:");
+    const where = formatPath(fd.path);
+    const displayKind = firstKind ?? fd.kind;
+    lines.push(`  ${displayKind} at ${where}`);
+    if (fd.left !== void 0 || fd.right !== void 0) {
+      lines.push(`    left: ${formatValue(fd.left, verbose)}`);
+      lines.push(`    right: ${formatValue(fd.right, verbose)}`);
+    }
+    lines.push("");
+  }
+  lines.push("Differences:");
+  if (result.differences.length === 0) {
+    lines.push("  (none)");
+    return lines.join("\n");
+  }
+  const showSides = (kind) => verbose || [
+    "run-status",
+    "step-status",
+    "error",
+    "duration",
+    "step-type",
+    "structure",
+    "step-added",
+    "step-removed"
+  ].includes(kind);
+  for (const d of result.differences) {
+    const tag = sev(`[${d.severity}]`, d.severity);
+    const pathStr = d.path !== void 0 ? ` ${formatPath(d.path)}` : "";
+    lines.push(`  ${tag} ${d.kind}${pathStr}`);
+    lines.push(`    ${d.message}`);
+    if (d.left !== void 0 || d.right !== void 0) {
+      if (showSides(d.kind)) {
+        lines.push(`    left: ${formatValue(d.left, verbose)}`);
+        lines.push(`    right: ${formatValue(d.right, verbose)}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// packages/core/src/diff/index.ts
+function diffTraceEvents(leftEvents, rightEvents, options) {
+  const left = manualTraceEventsToComparableRun(leftEvents);
+  const right = manualTraceEventsToComparableRun(rightEvents);
+  return diffRuns(left, right, options);
+}
 var TERMINAL_INDENT = "  ";
 var MAX_TERMINAL_NAME_LENGTH = 80;
 var MAX_TERMINAL_DEPTH = 10;
@@ -527,24 +2416,24 @@ function formatTerminalName(name) {
   return truncateName(name, MAX_TERMINAL_NAME_LENGTH);
 }
 function getStatusIcon(status) {
-  if (status === "success") return chalk__default.default.green("\u2714");
-  if (status === "error") return chalk__default.default.red("\u2716");
-  return chalk__default.default.yellow("\u23F3");
+  if (status === "success") return chalk2__default.default.green("\u2714");
+  if (status === "error") return chalk2__default.default.red("\u2716");
+  return chalk2__default.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}${chalk__default.default.yellow("\u23F3")} ${nm}`;
+      return `${ind}${chalk2__default.default.yellow("\u23F3")} ${nm}`;
     }
     const hasDur = durationMs !== void 0 && Number.isFinite(durationMs);
-    const dur = hasDur ? formatDuration(durationMs) : void 0;
+    const dur = hasDur ? formatDuration2(durationMs) : void 0;
     if (status === "running") {
-      return dur !== void 0 ? `${ind}${chalk__default.default.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${chalk__default.default.yellow("\u23F3")} ${nm}`;
+      return dur !== void 0 ? `${ind}${chalk2__default.default.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${chalk2__default.default.yellow("\u23F3")} ${nm}`;
     }
     if (!hasDur || dur === void 0) {
-      return `${ind}${chalk__default.default.yellow("\u23F3")} ${nm}`;
+      return `${ind}${chalk2__default.default.yellow("\u23F3")} ${nm}`;
     }
     if (status === "success") {
       return `${ind}${getStatusIcon("success")} ${nm} (${dur})`;
@@ -565,7 +2454,7 @@ function renderErrorLine(error, depth) {
 }
 function renderRunSummary(durationMs, status, traceFilePath) {
   try {
-    const dur = Number.isFinite(durationMs) ? formatDuration(durationMs) : formatDuration(0);
+    const dur = Number.isFinite(durationMs) ? formatDuration2(durationMs) : formatDuration2(0);
     const head = status === "error" ? `Failed in ${dur}` : `Completed in ${dur}`;
     const lines = [head];
     if (traceFilePath !== void 0 && traceFilePath.trim() !== "") {
@@ -580,7 +2469,7 @@ function printRunStart(runId, name) {
   if (isSilentContext()) return;
   try {
     safePrint("");
-    const header = `${chalk__default.default.cyan.bold("\u{1F50D} AgentInspect:")} ${formatTerminalName(name)} ${chalk__default.default.dim(`(${runId})`)}`;
+    const header = `${chalk2__default.default.cyan.bold("\u{1F50D} AgentInspect:")} ${formatTerminalName(name)} ${chalk2__default.default.dim(`(${runId})`)}`;
     safePrint(header);
   } catch {
   }
@@ -613,10 +2502,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" ? chalk__default.default.red : status === "running" ? chalk__default.default.yellow : chalk__default.default.green;
+        const color = status === "error" ? chalk2__default.default.red : status === "running" ? chalk2__default.default.yellow : chalk2__default.default.green;
         safePrint(color(line));
       } else {
-        safePrint(chalk__default.default.dim(line));
+        safePrint(chalk2__default.default.dim(line));
       }
     }
   } catch {
@@ -650,7 +2539,7 @@ async function inspectRun(name, fn, options) {
   }
   const runName = normalizeRunName(name);
   const runId = createRunId();
-  const traceDir = typeof options?.traceDir === "string" && options.traceDir.trim() !== "" ? options.traceDir.trim() : getDefaultTraceDir();
+  const traceDir = resolveTraceDir({ dir: options?.traceDir });
   const context = {
     runId,
     runName,
@@ -922,17 +2811,810 @@ function observe(agent, options) {
   }
 }
 
+// packages/core/src/exporters/types.ts
+var EXPORT_PAYLOAD_VERSION = "0.1.2";
+
+// packages/core/src/exporters/html-exporter.ts
+function renderTreeHtml(nodes, ulClass = "tree") {
+  if (nodes.length === 0) return "";
+  const parts = [`<ul class="${ulClass}">`];
+  for (const n of nodes) {
+    const ev = n.event;
+    const status = ev.status ?? "?";
+    const dur = ev.durationMs !== void 0 && Number.isFinite(ev.durationMs) ? `${ev.durationMs}ms` : "-";
+    parts.push("<li>");
+    parts.push(
+      `<span class="nm">${escapeHtml(ev.name)}</span> <span class="meta">[${escapeHtml(ev.kind)}] ${escapeHtml(status)} (${escapeHtml(dur)})</span>`
+    );
+    if (n.children.length > 0) {
+      parts.push(renderTreeHtml(n.children, "tree nested"));
+    }
+    parts.push("</li>");
+  }
+  parts.push("</ul>");
+  return parts.join("");
+}
+function exportHtml(tree, options) {
+  const warnings = [];
+  const includeMetadata = options?.includeMetadata ?? true;
+  const includeAttributes = options?.includeAttributes ?? false;
+  const includeErrors = options?.includeErrors ?? true;
+  const maxLen = options?.maxAttributeLength ?? 500;
+  const redacted = options?.redacted ?? true;
+  const titleName = escapeHtml(tree.name ?? tree.runId);
+  const summaryRows = [];
+  summaryRows.push(
+    `<tr><th scope="row">runId</th><td><code>${escapeHtml(tree.runId)}</code></td></tr>`
+  );
+  if (tree.name !== void 0) {
+    summaryRows.push(`<tr><th scope="row">name</th><td>${escapeHtml(tree.name)}</td></tr>`);
+  }
+  summaryRows.push(
+    `<tr><th scope="row">status</th><td>${escapeHtml(String(tree.status ?? "unknown"))}</td></tr>`
+  );
+  summaryRows.push(
+    `<tr><th scope="row">durationMs</th><td>${tree.durationMs !== void 0 ? escapeHtml(String(tree.durationMs)) : "\u2014"}</td></tr>`
+  );
+  summaryRows.push(
+    `<tr><th scope="row">startedAt</th><td>${tree.startedAt !== void 0 ? escapeHtml(String(tree.startedAt)) : "\u2014"}</td></tr>`
+  );
+  summaryRows.push(
+    `<tr><th scope="row">endedAt</th><td>${tree.endedAt !== void 0 ? escapeHtml(String(tree.endedAt)) : "\u2014"}</td></tr>`
+  );
+  summaryRows.push(
+    `<tr><th scope="row">totalEvents</th><td>${escapeHtml(String(tree.metadata.totalEvents))}</td></tr>`
+  );
+  let confidenceHtml = "";
+  if (includeMetadata) {
+    const cb = tree.metadata.confidenceBreakdown;
+    confidenceHtml += "<h3>Confidence breakdown</h3><table><thead><tr><th>bucket</th><th>count</th></tr></thead><tbody>";
+    for (const k of Object.keys(cb).sort()) {
+      const key = k;
+      confidenceHtml += `<tr><td>${escapeHtml(key)}</td><td>${cb[key]}</td></tr>`;
+    }
+    confidenceHtml += "</tbody></table>";
+    confidenceHtml += "<h3>Kind breakdown</h3><table><thead><tr><th>kind</th><th>count</th></tr></thead><tbody>";
+    for (const k of Object.keys(tree.metadata.kinds).sort()) {
+      const key = k;
+      const c = tree.metadata.kinds[key];
+      if (c > 0) confidenceHtml += `<tr><td>${escapeHtml(key)}</td><td>${c}</td></tr>`;
+    }
+    confidenceHtml += "</tbody></table>";
+  }
+  const flat = flattenTree(tree);
+  const errors = flat.filter((n) => n.event.status === "error");
+  let errorsHtml = "";
+  if (includeErrors && errors.length > 0) {
+    errorsHtml += "<h2>Errors</h2><ul>";
+    for (const n of errors) {
+      const msg = n.event.attributes && typeof n.event.attributes.error === "object" ? safeString2(
+        n.event.attributes.error.message,
+        maxLen
+      ) : "";
+      errorsHtml += `<li><strong>${escapeHtml(n.event.name)}</strong> (${escapeHtml(n.event.eventId)}): ${escapeHtml(msg || "error")}</li>`;
+    }
+    errorsHtml += "</ul>";
+  }
+  let attrsHtml = "";
+  if (includeAttributes) {
+    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, {
+        maxLength: maxLen,
+        redacted
+      });
+      attrsHtml += `<h3>${escapeHtml(n.event.name)}</h3><pre class="json">${escapeHtml(stableJson(compact, true))}</pre>`;
+    }
+    warnings.push(
+      "Attributes may still contain sensitive data; review exports before sharing."
+    );
+  }
+  const css = `
+body{font-family:system-ui,sans-serif;line-height:1.5;margin:1.5rem;max-width:960px;color:#111}
+h1{font-size:1.35rem}
+h2{font-size:1.1rem;margin-top:1.5rem}
+table{border-collapse:collapse;margin:0.75rem 0}
+th,td{border:1px solid #ccc;padding:0.35rem 0.6rem;text-align:left}
+th{background:#f5f5f5}
+pre.json{background:#f8f8f8;padding:0.75rem;overflow:auto;font-size:0.85rem}
+ul.tree{list-style:none;padding-left:1rem}
+ul.tree.nested{padding-left:1.25rem;border-left:1px solid #ddd;margin:0.25rem 0}
+.nm{font-weight:600}
+.meta{color:#555;font-size:0.9rem}
+footer{margin-top:2rem;font-size:0.85rem;color:#555}
+`.trim();
+  const html = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>${titleName}</title>
+<style>${css}</style>
+</head>
+<body>
+<header><h1>AgentInspect Run: ${titleName}</h1></header>
+<p class="note">Generated locally by AgentInspect.</p>
+${includeMetadata ? `<section class="summary"><h2>Summary</h2><table>${summaryRows.join("")}</table>${confidenceHtml}</section>` : ""}
+<section class="tree"><h2>Execution tree</h2>${tree.children.length > 0 ? renderTreeHtml(tree.children) : "<p>No steps recorded.</p>"}</section>
+${errorsHtml}
+${attrsHtml}
+<footer>Generated locally by AgentInspect. Review for sensitive data before sharing.</footer>
+</body>
+</html>`;
+  return {
+    format: "html",
+    content: html,
+    contentType: "text/html",
+    fileExtension: ".html",
+    warnings
+  };
+}
+
+// packages/core/src/exporters/markdown-exporter.ts
+function renderTreeAscii(nodes, indent = "") {
+  const lines = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    const last = i === nodes.length - 1;
+    const branch = last ? "\u2514\u2500 " : "\u251C\u2500 ";
+    const ev = n.event;
+    const status = ev.status ?? "?";
+    const dur = ev.durationMs !== void 0 && Number.isFinite(ev.durationMs) ? `${ev.durationMs}ms` : "-";
+    lines.push(`${indent}${branch}${escapeMarkdown(ev.name)} [${ev.kind}] ${status} (${dur})`);
+    const nextIndent = indent + (last ? "   " : "\u2502  ");
+    if (n.children.length > 0) {
+      const childStr = renderTreeAscii(n.children, nextIndent);
+      if (childStr.length > 0) lines.push(childStr);
+    }
+  }
+  return lines.join("\n");
+}
+function exportMarkdown(tree, options) {
+  const warnings = [];
+  const includeMetadata = options?.includeMetadata ?? true;
+  const includeAttributes = options?.includeAttributes ?? false;
+  const includeErrors = options?.includeErrors ?? true;
+  const maxLen = options?.maxAttributeLength ?? 500;
+  const redacted = options?.redacted ?? true;
+  const titleName = tree.name ?? tree.runId;
+  const lines = [];
+  lines.push(`# AgentInspect Run: ${escapeMarkdown(titleName)}`);
+  lines.push("");
+  lines.push("Generated locally by AgentInspect. Review for sensitive data before sharing.");
+  lines.push("");
+  if (includeMetadata) {
+    lines.push("## Summary");
+    lines.push("");
+    lines.push(`- **runId**: ${escapeMarkdown(tree.runId)}`);
+    if (tree.name !== void 0) lines.push(`- **name**: ${escapeMarkdown(tree.name)}`);
+    lines.push(`- **status**: ${escapeMarkdown(String(tree.status ?? "unknown"))}`);
+    lines.push(
+      `- **durationMs**: ${tree.durationMs !== void 0 ? escapeMarkdown(String(tree.durationMs)) : "-"}`
+    );
+    lines.push(
+      `- **startedAt**: ${tree.startedAt !== void 0 ? escapeMarkdown(String(tree.startedAt)) : "-"}`
+    );
+    lines.push(
+      `- **endedAt**: ${tree.endedAt !== void 0 ? escapeMarkdown(String(tree.endedAt)) : "-"}`
+    );
+    lines.push(`- **totalEvents**: ${tree.metadata.totalEvents}`);
+    lines.push("");
+    lines.push("### Confidence breakdown");
+    lines.push("");
+    lines.push("| bucket | count |");
+    lines.push("| --- | --- |");
+    for (const k of Object.keys(tree.metadata.confidenceBreakdown).sort()) {
+      const key = k;
+      lines.push(
+        `| ${escapeMarkdown(key)} | ${tree.metadata.confidenceBreakdown[key]} |`
+      );
+    }
+    lines.push("");
+    lines.push("### Kind breakdown");
+    lines.push("");
+    lines.push("| kind | count |");
+    lines.push("| --- | --- |");
+    for (const k of Object.keys(tree.metadata.kinds).sort()) {
+      const key = k;
+      const c = tree.metadata.kinds[key];
+      if (c > 0) lines.push(`| ${escapeMarkdown(key)} | ${c} |`);
+    }
+    lines.push("");
+  }
+  lines.push("## Execution tree");
+  lines.push("");
+  lines.push("```text");
+  lines.push(
+    tree.children.length > 0 ? renderTreeAscii(tree.children) : "(no steps)"
+  );
+  lines.push("```");
+  lines.push("");
+  const flat = flattenTree(tree);
+  const errors = flat.filter((n) => n.event.status === "error");
+  if (includeErrors && errors.length > 0) {
+    lines.push("## Errors");
+    lines.push("");
+    for (const n of errors) {
+      const msg = n.event.attributes && typeof n.event.attributes.error === "object" ? safeString2(
+        n.event.attributes.error.message,
+        maxLen
+      ) : "";
+      lines.push(
+        `- **${escapeMarkdown(n.event.name)}** (${escapeMarkdown(n.event.eventId)}): ${escapeMarkdown(msg || "error")}`
+      );
+    }
+    lines.push("");
+  }
+  if (includeAttributes) {
+    lines.push("## Attributes (bounded)");
+    lines.push("");
+    for (const n of flat) {
+      if (!n.event.attributes || Object.keys(n.event.attributes).length === 0) continue;
+      const compact = compactAttributes(n.event.attributes, {
+        maxLength: maxLen,
+        redacted
+      });
+      lines.push(`### ${escapeMarkdown(n.event.name)}`);
+      lines.push("");
+      lines.push("```json");
+      lines.push(stableJson(compact, true));
+      lines.push("```");
+      lines.push("");
+    }
+    warnings.push(
+      "Attributes may still contain sensitive data; review exports before sharing."
+    );
+  }
+  return {
+    format: "markdown",
+    content: lines.join("\n"),
+    contentType: "text/markdown",
+    fileExtension: ".md",
+    warnings
+  };
+}
+function hexFrom(seed, byteLen) {
+  return crypto__default.default.createHash("sha256").update(seed, "utf8").digest("hex").slice(0, byteLen * 2);
+}
+function mapInspectKindToOI(kind, warnings) {
+  switch (kind) {
+    case "LLM":
+      return { openInferenceKind: "LLM" };
+    case "TOOL":
+      return { openInferenceKind: "TOOL" };
+    case "CHAIN":
+      return { openInferenceKind: "CHAIN" };
+    case "RETRIEVER":
+      return { openInferenceKind: "RETRIEVER" };
+    case "AGENT":
+      return { openInferenceKind: "AGENT" };
+    case "DECISION":
+      warnings.push(
+        `Ambiguous kind DECISION mapped to CHAIN for span compatibility (${EXPORT_PAYLOAD_VERSION}).`
+      );
+      return { openInferenceKind: "CHAIN" };
+    case "RESULT":
+      warnings.push(
+        `Ambiguous kind RESULT mapped to UNKNOWN for span compatibility (${EXPORT_PAYLOAD_VERSION}).`
+      );
+      return { openInferenceKind: "UNKNOWN" };
+    case "ERROR":
+      warnings.push(`ERROR kind mapped to CHAIN for span compatibility.`);
+      return { openInferenceKind: "CHAIN" };
+    case "LOG":
+    case "LOGIC":
+    case "RUN":
+      warnings.push(`${kind} mapped to CHAIN for span compatibility.`);
+      return { openInferenceKind: "CHAIN" };
+    default:
+      warnings.push(`Unhandled InspectKind ${kind} mapped to UNKNOWN.`);
+      return { openInferenceKind: "UNKNOWN" };
+  }
+}
+function exportOpenInference(tree, options) {
+  const warnings = [
+    "OpenInference-compatible JSON export is experimental until verified against specific backends.",
+    "This file was generated locally and not sent anywhere."
+  ];
+  const traceId = hexFrom(`trace:${tree.runId}`, 16);
+  const includeAttributes = options?.includeAttributes ?? false;
+  const maxLen = options?.maxAttributeLength ?? 500;
+  const pretty = options?.pretty ?? true;
+  const spans = [];
+  for (const n of flattenTree(tree)) {
+    const ev = n.event;
+    const spanId = hexFrom(`${tree.runId}:${ev.eventId}`, 8);
+    const parentSpanHex = ev.parentId ? hexFrom(`${tree.runId}:${ev.parentId}`, 8) : void 0;
+    const startNs = Math.round(ev.timestamp * 1e6);
+    let endNs;
+    if (ev.durationMs !== void 0 && Number.isFinite(ev.durationMs)) {
+      endNs = startNs + Math.round(ev.durationMs * 1e6);
+    }
+    const { openInferenceKind } = mapInspectKindToOI(ev.kind, warnings);
+    const attrs = {
+      "openinference.span.kind": openInferenceKind,
+      "agent_inspect.kind": ev.kind,
+      "agent_inspect.confidence": ev.confidence,
+      "agent_inspect.source.type": ev.source.type,
+      "agent_inspect.run_id": tree.runId,
+      "agent_inspect.event_id": ev.eventId,
+      "agent_inspect.status": ev.status ?? "unset"
+    };
+    if (ev.durationMs !== void 0) {
+      attrs["agent_inspect.duration_ms"] = ev.durationMs;
+    }
+    const meta = ev.attributes;
+    if (meta?.model !== void 0 && typeof meta.model === "string") {
+      attrs["llm.model_name"] = meta.model;
+    }
+    const tokens = meta?.tokens;
+    if (tokens && typeof tokens === "object" && tokens !== null) {
+      const inp = tokens.input;
+      const outp = tokens.output;
+      if (typeof inp === "number") attrs["llm.token_count.prompt"] = inp;
+      if (typeof outp === "number") attrs["llm.token_count.completion"] = outp;
+    }
+    if (includeAttributes && meta && typeof meta === "object") {
+      for (const [k, v] of Object.entries(meta)) {
+        if (k === "tokens" || k === "model") continue;
+        if (v !== void 0 && v !== null && typeof v !== "object") {
+          attrs[`agent_inspect.preview.${k}`] = typeof v === "string" ? v.slice(0, maxLen) : v;
+        }
+      }
+    }
+    let status;
+    if (ev.status === "error") {
+      const msg = meta && typeof meta.error === "object" && meta.error !== null ? String(meta.error.message ?? "error") : "error";
+      status = { code: "ERROR", message: msg.slice(0, maxLen) };
+    } else if (ev.status === "ok") {
+      status = { code: "OK" };
+    } else {
+      status = { code: "UNSET" };
+    }
+    spans.push({
+      trace_id: traceId,
+      span_id: spanId,
+      parent_span_id: parentSpanHex,
+      name: ev.name,
+      start_time_unix_nano: startNs,
+      end_time_unix_nano: endNs,
+      attributes: attrs,
+      status
+    });
+  }
+  const payload = {
+    exporter: "agent-inspect",
+    format: "openinference",
+    compatibility: "openinference-compatible",
+    version: EXPORT_PAYLOAD_VERSION,
+    trace_id: traceId,
+    spans,
+    warnings
+  };
+  return {
+    format: "openinference",
+    content: JSON.stringify(payload, null, pretty ? 2 : void 0),
+    contentType: "application/json",
+    fileExtension: ".openinference.json",
+    warnings
+  };
+}
+function hexFrom2(seed, byteLen) {
+  return crypto__default.default.createHash("sha256").update(seed, "utf8").digest("hex").slice(0, byteLen * 2);
+}
+function stringAttr(key, value) {
+  return { key, value: { stringValue: value } };
+}
+function intAttr(key, value) {
+  return { key, value: { intValue: String(value) } };
+}
+function genAiOperationName(kind) {
+  switch (kind) {
+    case "LLM":
+      return "generate_content";
+    case "TOOL":
+      return "execute_tool";
+    case "AGENT":
+      return "invoke_agent";
+    default:
+      return void 0;
+  }
+}
+function exportOtlpJson(tree, options) {
+  const warnings = [
+    "OTLP JSON export uses OTel GenAI-aligned attributes where applicable; experimental until verified against specific collectors.",
+    "Not OTLP gRPC/protobuf \u2014 JSON mapping only. Generated locally; no network upload."
+  ];
+  const traceId = hexFrom2(`trace:${tree.runId}`, 16);
+  const includeAttributes = options?.includeAttributes ?? false;
+  const maxLen = options?.maxAttributeLength ?? 500;
+  const pretty = options?.pretty ?? true;
+  const flat = flattenTree(tree);
+  const spans = [];
+  for (const n of flat) {
+    const ev = n.event;
+    const spanId = hexFrom2(`${tree.runId}:${ev.eventId}`, 8);
+    const parentSpanId = ev.parentId ? hexFrom2(`${tree.runId}:${ev.parentId}`, 8) : void 0;
+    const startNs = String(Math.round(ev.timestamp * 1e6));
+    let endNs;
+    if (ev.durationMs !== void 0 && Number.isFinite(ev.durationMs)) {
+      endNs = String(Math.round(ev.timestamp * 1e6 + ev.durationMs * 1e6));
+    }
+    const attrs = [
+      stringAttr("agent_inspect.kind", ev.kind),
+      stringAttr("agent_inspect.confidence", ev.confidence),
+      stringAttr("agent_inspect.source.type", ev.source.type),
+      stringAttr("agent_inspect.run_id", tree.runId),
+      stringAttr("agent_inspect.event_id", ev.eventId),
+      stringAttr("agent_inspect.status", ev.status ?? "unset")
+    ];
+    if (ev.durationMs !== void 0) {
+      attrs.push(intAttr("agent_inspect.duration_ms", ev.durationMs));
+    }
+    const op = genAiOperationName(ev.kind);
+    if (op !== void 0) {
+      attrs.push(stringAttr("gen_ai.operation.name", op));
+    }
+    const meta = ev.attributes;
+    if (meta?.model !== void 0 && typeof meta.model === "string") {
+      attrs.push(stringAttr("gen_ai.request.model", meta.model.slice(0, maxLen)));
+    }
+    const tokens = meta?.tokens;
+    if (tokens && typeof tokens === "object" && tokens !== null) {
+      const inp = tokens.input;
+      const outp = tokens.output;
+      if (typeof inp === "number") attrs.push(intAttr("gen_ai.usage.input_tokens", inp));
+      if (typeof outp === "number") attrs.push(intAttr("gen_ai.usage.output_tokens", outp));
+    }
+    if (includeAttributes && meta && typeof meta === "object") {
+      for (const [k, v] of Object.entries(meta)) {
+        if (k === "tokens" || k === "model") continue;
+        if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+          attrs.push(
+            stringAttr(
+              `agent_inspect.preview.${k}`,
+              typeof v === "string" ? v.slice(0, maxLen) : String(v)
+            )
+          );
+        }
+      }
+    }
+    let statusCode = "STATUS_CODE_UNSET";
+    let statusMessage;
+    if (ev.status === "error") {
+      statusCode = "STATUS_CODE_ERROR";
+      statusMessage = meta && typeof meta.error === "object" && meta.error !== null ? String(meta.error.message ?? "error").slice(0, maxLen) : "error";
+    } else if (ev.status === "ok") {
+      statusCode = "STATUS_CODE_OK";
+    }
+    const spanJson = {
+      traceId,
+      spanId,
+      name: ev.name,
+      kind: "SPAN_KIND_INTERNAL",
+      startTimeUnixNano: startNs,
+      attributes: attrs,
+      status: {
+        code: statusCode,
+        ...statusMessage !== void 0 ? { message: statusMessage } : {}
+      }
+    };
+    if (parentSpanId !== void 0) {
+      spanJson.parentSpanId = parentSpanId;
+    }
+    if (endNs !== void 0) {
+      spanJson.endTimeUnixNano = endNs;
+    }
+    spans.push(spanJson);
+  }
+  const payload = {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [stringAttr("service.name", "agent-inspect")]
+        },
+        scopeSpans: [
+          {
+            scope: { name: "agent-inspect" },
+            spans
+          }
+        ]
+      }
+    ]
+  };
+  return {
+    format: "otlp-json",
+    content: JSON.stringify(payload, null, pretty ? 2 : void 0),
+    contentType: "application/json",
+    fileExtension: ".otlp.json",
+    warnings
+  };
+}
+
+// packages/core/src/exporters/validation.ts
+var EXPERIMENTAL = "Experimental compatibility export \u2014 verify against your target tooling before relying on it.";
+function validateExportContent(format, content) {
+  const errors = [];
+  const warnings = [EXPERIMENTAL];
+  if (format === "markdown") {
+    if (!content.startsWith("# AgentInspect Run")) {
+      errors.push('Markdown export must start with "# AgentInspect Run"');
+    }
+    return { ok: errors.length === 0, format, errors, warnings };
+  }
+  if (format === "html") {
+    const lower = content.toLowerCase();
+    if (!lower.includes("<!doctype html")) {
+      errors.push("HTML export must include <!doctype html>");
+    }
+    if (/<\s*script\b/i.test(content)) {
+      errors.push("HTML export must not contain script tags");
+    }
+    if (/<\s*link\b[^>]*href\s*=/i.test(content)) {
+      warnings.push("HTML export contains link tags \u2014 ensure no external stylesheets.");
+    }
+    return { ok: errors.length === 0, format, errors, warnings };
+  }
+  if (format === "openinference") {
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      errors.push("OpenInference export is not valid JSON");
+      return { ok: false, format, errors, warnings };
+    }
+    if (!parsed || typeof parsed !== "object") {
+      errors.push("OpenInference export JSON must be an object");
+      return { ok: false, format, errors, warnings };
+    }
+    const o = parsed;
+    if (o.format !== "openinference") {
+      errors.push('OpenInference export must include format: "openinference"');
+    }
+    if (!Array.isArray(o.spans)) {
+      errors.push("OpenInference export must include a spans array");
+    }
+    warnings.push("OpenInference-compatible JSON is not guaranteed for every backend.");
+    return { ok: errors.length === 0, format, errors, warnings };
+  }
+  if (format === "otlp-json") {
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      errors.push("OTLP JSON export is not valid JSON");
+      return { ok: false, format, errors, warnings };
+    }
+    if (!parsed || typeof parsed !== "object") {
+      errors.push("OTLP JSON export must be an object");
+      return { ok: false, format, errors, warnings };
+    }
+    const o = parsed;
+    if (!Array.isArray(o.resourceSpans)) {
+      errors.push("OTLP JSON export must include resourceSpans array");
+    }
+    warnings.push(
+      "OTLP JSON mapping uses OTel GenAI-aligned attributes where applicable; collectors may require transformation."
+    );
+    return { ok: errors.length === 0, format, errors, warnings };
+  }
+  errors.push(`Unsupported export format`);
+  return { ok: false, format, errors, warnings };
+}
+
+// packages/core/src/exporters/manual-trace-adapter.ts
+function stepTypeToInspectKind(t) {
+  switch (t) {
+    case "llm":
+      return "LLM";
+    case "tool":
+      return "TOOL";
+    case "decision":
+      return "DECISION";
+    case "run":
+      return "CHAIN";
+    default:
+      return "LOGIC";
+  }
+}
+function mapStepStatus2(s) {
+  if (s === void 0) return "running";
+  if (s === "success") return "ok";
+  return "error";
+}
+function manualTraceEventsToRunTree(events) {
+  const started = events.find((e) => e.event === "run_started");
+  if (!started || started.event !== "run_started") {
+    throw new Error("Invalid trace: missing run_started");
+  }
+  const runId = started.runId;
+  const runName = started.name;
+  const completedAll = events.filter((e) => e.event === "run_completed");
+  const lastCompleted = completedAll[completedAll.length - 1];
+  let runStatus;
+  if (lastCompleted === void 0) {
+    runStatus = "running";
+  } else if (lastCompleted.status === "success") {
+    runStatus = "ok";
+  } else {
+    runStatus = "error";
+  }
+  const startedAt = started.startTime;
+  const endedAt = lastCompleted !== void 0 && runStatus !== "running" ? lastCompleted.endTime : void 0;
+  const durationMs = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const steps = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.event !== "step_started") continue;
+    const s = e;
+    steps.set(s.stepId, {
+      id: s.stepId,
+      parentId: s.parentId,
+      name: s.name,
+      type: s.type,
+      startTime: s.startTime,
+      timestamp: s.timestamp,
+      metadata: s.metadata
+    });
+  }
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const acc = steps.get(e.stepId);
+    if (!acc) continue;
+    acc.status = e.status;
+    acc.endTime = e.endTime;
+    acc.durationMs = e.durationMs;
+    if (e.error?.message) {
+      acc.error = e.error;
+    }
+  }
+  const inspectNodes = /* @__PURE__ */ new Map();
+  for (const acc of steps.values()) {
+    const kind = stepTypeToInspectKind(acc.type);
+    const status = mapStepStatus2(acc.status);
+    const attrs = { ...acc.metadata ?? {} };
+    if (acc.error?.message) {
+      attrs.error = acc.error;
+    }
+    const evt = {
+      eventId: acc.id,
+      runId,
+      parentId: acc.parentId,
+      name: acc.name,
+      kind,
+      timestamp: acc.timestamp,
+      status,
+      durationMs: acc.durationMs,
+      attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+      confidence: "explicit",
+      source: { type: "manual" }
+    };
+    inspectNodes.set(acc.id, { event: evt, children: [], depth: 0 });
+  }
+  const roots = [];
+  const sortByStart = (a, b) => a.event.timestamp - b.event.timestamp;
+  for (const node of inspectNodes.values()) {
+    const pid = node.event.parentId;
+    if (pid !== void 0 && inspectNodes.has(pid)) {
+      inspectNodes.get(pid).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  roots.sort(sortByStart);
+  for (const n of inspectNodes.values()) {
+    n.children.sort(sortByStart);
+  }
+  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 = zeroKinds();
+  function countWalk(nodes) {
+    for (const n of nodes) {
+      confidenceBreakdown[n.event.confidence] += 1;
+      kinds[n.event.kind] += 1;
+      if (n.children.length > 0) countWalk(n.children);
+    }
+  }
+  countWalk(roots);
+  return {
+    runId,
+    name: runName,
+    status: runStatus,
+    startedAt,
+    endedAt,
+    durationMs,
+    children: roots,
+    metadata: {
+      totalEvents: inspectNodes.size,
+      confidenceBreakdown,
+      kinds
+    }
+  };
+}
+
+// packages/core/src/exporters/index.ts
+function mergeExportDefaults(options) {
+  return {
+    format: options.format,
+    includeMetadata: options.includeMetadata ?? true,
+    includeAttributes: options.includeAttributes ?? false,
+    includeErrors: options.includeErrors ?? true,
+    pretty: options.pretty ?? true,
+    redacted: options.redacted ?? true,
+    maxAttributeLength: options.maxAttributeLength ?? 500
+  };
+}
+function exportRunTree(tree, options) {
+  const opts = mergeExportDefaults(options);
+  switch (opts.format) {
+    case "markdown":
+      return exportMarkdown(tree, opts);
+    case "html":
+      return exportHtml(tree, opts);
+    case "openinference":
+      return exportOpenInference(tree, opts);
+    case "otlp-json":
+      return exportOtlpJson(tree, opts);
+    default: {
+      const _x = opts.format;
+      throw new Error(`Unsupported export format: ${String(_x)}`);
+    }
+  }
+}
+function validateExport(result) {
+  const base = validateExportContent(result.format, result.content);
+  return {
+    ok: base.ok,
+    format: base.format,
+    errors: base.errors,
+    warnings: [...result.warnings, ...base.warnings]
+  };
+}
+
+exports.DEFAULT_LOG_INGEST_CONFIG = DEFAULT_LOG_INGEST_CONFIG;
+exports.DEFAULT_REDACT_KEYS = DEFAULT_REDACT_KEYS;
 exports.DEFAULT_TRACE_DIR_NAME = DEFAULT_TRACE_DIR_NAME;
+exports.EXPORT_PAYLOAD_VERSION = EXPORT_PAYLOAD_VERSION;
+exports.EventNormalizer = EventNormalizer;
 exports.FALLBACK_TRACE_DIR = FALLBACK_TRACE_DIR;
+exports.JsonLogParser = JsonLogParser;
+exports.LiveLogAccumulator = LiveLogAccumulator;
+exports.Log4jsParser = Log4jsParser;
 exports.MAX_NAME_LENGTH = MAX_NAME_LENGTH;
 exports.MAX_TERMINAL_DEPTH = MAX_TERMINAL_DEPTH;
 exports.MAX_TERMINAL_NAME_LENGTH = MAX_TERMINAL_NAME_LENGTH;
 exports.RUNS_DIR_NAME = RUNS_DIR_NAME;
+exports.Redactor = Redactor;
 exports.TERMINAL_INDENT = TERMINAL_INDENT;
+exports.TraceDirectory = TraceDirectory;
+exports.TreeBuilder = TreeBuilder;
+exports.buildRunSummary = buildRunSummary;
+exports.compactAttributes = compactAttributes;
 exports.createRunId = createRunId;
 exports.createStepId = createStepId;
+exports.diffRuns = diffRuns;
+exports.diffTraceEvents = diffTraceEvents;
 exports.ensureTraceDir = ensureTraceDir;
-exports.formatDuration = formatDuration;
+exports.escapeHtml = escapeHtml;
+exports.escapeMarkdown = escapeMarkdown;
+exports.exportHtml = exportHtml;
+exports.exportMarkdown = exportMarkdown;
+exports.exportOpenInference = exportOpenInference;
+exports.exportOtlpJson = exportOtlpJson;
+exports.exportRunTree = exportRunTree;
+exports.extractMetadata = extractMetadata;
+exports.filterTraces = filterTraces;
+exports.flattenTree = flattenTree;
+exports.formatDuration = formatDuration2;
 exports.formatError = formatError;
 exports.formatTerminalName = formatTerminalName;
 exports.formatTimestamp = formatTimestamp;
@@ -950,12 +3632,22 @@ exports.getTraceFilePath = getTraceFilePath;
 exports.hasActiveContext = hasActiveContext;
 exports.initializeTraceFile = initializeTraceFile;
 exports.inspectRun = inspectRun;
+exports.isAgentInspectTrace = isAgentInspectTrace;
 exports.isSilentContext = isSilentContext;
 exports.isStepStatus = isStepStatus;
 exports.isStepType = isStepType;
 exports.isTraceEvent = isTraceEvent;
 exports.listTraceFiles = listTraceFiles;
+exports.loadLogIngestConfig = loadLogIngestConfig;
+exports.manualTraceEventsToComparableRun = manualTraceEventsToComparableRun;
+exports.manualTraceEventsToRunTree = manualTraceEventsToRunTree;
+exports.matchMapping = matchMapping;
+exports.mergeExportDefaults = mergeExportDefaults;
+exports.mergeLogIngestConfig = mergeLogIngestConfig;
 exports.observe = observe;
+exports.parseDuration = parseDuration;
+exports.parseLogLine = parseLogLine;
+exports.parseLogsToTrees = parseLogsToTrees;
 exports.printError = printError;
 exports.printFailedAt = printFailedAt;
 exports.printRunComplete = printRunComplete;
@@ -965,15 +3657,25 @@ exports.printStepStart = printStepStart;
 exports.readTraceEvents = readTraceEvents;
 exports.readTraceFile = readTraceFile;
 exports.renderErrorLine = renderErrorLine;
+exports.renderRunDiff = renderRunDiff;
 exports.renderRunSummary = renderRunSummary;
+exports.renderRunTree = renderRunTree;
+exports.renderRunTrees = renderRunTrees;
 exports.renderStepLine = renderStepLine;
+exports.resolveTraceDir = resolveTraceDir;
 exports.runWithContext = runWithContext;
 exports.runWithStepContext = runWithStepContext;
+exports.safeString = safeString2;
 exports.serializeEvent = serializeEvent;
+exports.stableJson = stableJson;
 exports.step = step;
+exports.summarizeTree = summarizeTree;
 exports.truncateName = truncateName;
 exports.validateEvent = validateEvent;
+exports.validateExport = validateExport;
+exports.validateExportContent = validateExportContent;
 exports.warn = warn;
+exports.wildcardMatch = wildcardMatch;
 exports.writeTraceEvent = writeTraceEvent;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map