agent-inspect 1.2.0 → 1.4.0

package/packages/cli/dist/index.mjs

@@ -467,7 +467,7 @@ function stableHash(value) {
   const h = crypto.createHash("sha256").update(value, "utf8").digest("hex");
   return h.slice(0, 8);
 }
-function compileRules(rules) {
+function compileRules(rules, extraKeys) {
   const out = /* @__PURE__ */ new Map();
   const set = (r) => {
     const k = toKey(r.key);
@@ -476,6 +476,11 @@ function compileRules(rules) {
   for (const k of DEFAULT_REDACT_KEYS) {
     set({ key: k, strategy: "full" });
   }
+  for (const k of extraKeys ?? []) {
+    if (typeof k === "string" && k.length > 0) {
+      set({ key: k, strategy: "full" });
+    }
+  }
   for (const r of rules ?? []) {
     if (typeof r === "string") {
       set({ key: r, strategy: "full" });
@@ -493,7 +498,7 @@ function compileRules(rules) {
 var Redactor = class {
   #rules;
   constructor(options) {
-    this.#rules = compileRules(options?.rules);
+    this.#rules = compileRules(options?.rules, options?.extraKeys);
   }
   redactValue(key, value) {
     const k = toKey(key);
@@ -1195,6 +1200,91 @@ function warn(message, error) {
   }
   console.warn(`${base}: ${formatError(error).message}`);
 }
+
+// packages/core/src/redaction-profiles.ts
+var SHARE_PROFILE_EXTRA_KEYS = [
+  "userEmail",
+  "customerEmail",
+  "phone",
+  "phoneNumber",
+  "address",
+  "ip",
+  "ipAddress",
+  "sessionId",
+  "requestId",
+  "correlationId",
+  "decisionId",
+  "groupId",
+  "customerId",
+  "userId",
+  "accountId",
+  "tenantId",
+  "orgId",
+  "organizationId",
+  "traceId",
+  "spanId",
+  "parentSpanId"
+];
+var STRICT_PROFILE_EXTRA_KEYS = [
+  "prompt",
+  "completion",
+  "input",
+  "output",
+  "inputPreview",
+  "outputPreview",
+  "message",
+  "messages",
+  "transcript",
+  "context",
+  "document",
+  "documents",
+  "chunk",
+  "chunks",
+  "retrieval",
+  "query"
+];
+function resolveRedactionProfile(profile = "local") {
+  switch (profile) {
+    case "local":
+      return { profile: "local", extraKeys: [] };
+    case "share":
+      return {
+        profile: "share",
+        extraKeys: SHARE_PROFILE_EXTRA_KEYS,
+        maxMetadataValueLengthCap: 500,
+        maxPreviewLengthCap: 200
+      };
+    case "strict":
+      return {
+        profile: "strict",
+        extraKeys: [...SHARE_PROFILE_EXTRA_KEYS, ...STRICT_PROFILE_EXTRA_KEYS],
+        maxMetadataValueLengthCap: 200,
+        maxPreviewLengthCap: 80
+      };
+    default:
+      return { profile: "local", extraKeys: [] };
+  }
+}
+function isPreviewKey(key) {
+  return key.toLowerCase().includes("preview");
+}
+function applyProfileMetadataCaps(maxMetadataValueLength, maxPreviewLength, resolved) {
+  let meta = maxMetadataValueLength;
+  let preview = maxPreviewLength;
+  if (resolved.maxMetadataValueLengthCap !== void 0) {
+    meta = Math.min(meta, resolved.maxMetadataValueLengthCap);
+  }
+  if (resolved.maxPreviewLengthCap !== void 0) {
+    preview = Math.min(preview, resolved.maxPreviewLengthCap);
+  }
+  return { maxMetadataValueLength: meta, maxPreviewLength: preview };
+}
+function truncateStringForProfile(value, key, maxMetadataValueLength, maxPreviewLength) {
+  const max = isPreviewKey(key) ? maxPreviewLength : maxMetadataValueLength;
+  if (max <= 0) return "\u2026";
+  if (value.length <= max) return value;
+  return `${value.slice(0, max)}\u2026`;
+}
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1345,7 +1435,7 @@ var DEFAULT_MAX_EVENT_BYTES = 65536;
 function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isPreviewKey(key) {
+function isPreviewKey2(key) {
   return key.toLowerCase().includes("preview");
 }
 function truncateString(value, maxLen) {
@@ -1362,11 +1452,28 @@ function resolveTraceSafetyOptions(options) {
   {
     redactEnabled = true;
   }
+  const profile = options?.redactionProfile ?? "local";
+  const resolvedProfile = resolveRedactionProfile(profile);
+  const userMaxMetadata = "undefined" === "number" && Number.isFinite(options.maxMetadataValueLength) && options.maxMetadataValueLength >= 0 ? Math.floor(options.maxMetadataValueLength) : void 0;
+  const userMaxPreview = "undefined" === "number" && Number.isFinite(options.maxPreviewLength) && options.maxPreviewLength >= 0 ? Math.floor(options.maxPreviewLength) : void 0;
+  let maxMetadataValueLength = userMaxMetadata ?? DEFAULT_MAX_METADATA_VALUE_LENGTH;
+  let maxPreviewLength = userMaxPreview ?? DEFAULT_MAX_PREVIEW_LENGTH;
+  if (redactEnabled && profile !== "local") {
+    const capped = applyProfileMetadataCaps(
+      maxMetadataValueLength,
+      maxPreviewLength,
+      resolvedProfile
+    );
+    maxMetadataValueLength = capped.maxMetadataValueLength;
+    maxPreviewLength = capped.maxPreviewLength;
+  }
   return {
     redactEnabled,
     redactionRules,
-    maxMetadataValueLength: "undefined" === "number" && Number.isFinite(options.maxMetadataValueLength) && options.maxMetadataValueLength >= 0 ? Math.floor(options.maxMetadataValueLength) : DEFAULT_MAX_METADATA_VALUE_LENGTH,
-    maxPreviewLength: "undefined" === "number" && Number.isFinite(options.maxPreviewLength) && options.maxPreviewLength >= 0 ? Math.floor(options.maxPreviewLength) : DEFAULT_MAX_PREVIEW_LENGTH,
+    redactionProfile: profile,
+    profileExtraKeys: redactEnabled ? resolvedProfile.extraKeys : [],
+    maxMetadataValueLength,
+    maxPreviewLength,
     maxEventBytes: "undefined" === "number" && Number.isFinite(options.maxEventBytes) && options.maxEventBytes > 0 ? Math.floor(options.maxEventBytes) : DEFAULT_MAX_EVENT_BYTES
   };
 }
@@ -1374,7 +1481,7 @@ function boundMetadataValue(key, value, opts, seen, depth) {
   if (depth > 32) return "[MaxDepth]";
   if (value === null || typeof value !== "object") {
     if (typeof value === "string") {
-      const max = isPreviewKey(key) ? opts.maxPreviewLength : opts.maxMetadataValueLength;
+      const max = isPreviewKey2(key) ? opts.maxPreviewLength : opts.maxMetadataValueLength;
       return truncateString(value, max);
     }
     return value;
@@ -1400,7 +1507,10 @@ function boundMetadataValue(key, value, opts, seen, depth) {
 }
 function redactMetadata(metadata, opts) {
   if (!opts.redactEnabled) return { ...metadata };
-  const redactor = new Redactor({ rules: opts.redactionRules });
+  const redactor = new Redactor({
+    rules: opts.redactionRules,
+    extraKeys: opts.profileExtraKeys
+  });
   return redactor.redactRecord(metadata);
 }
 function prepareMetadataForDisk(metadata, opts) {
@@ -1886,6 +1996,574 @@ function filterTraces(traces, options) {
   }
   return out;
 }
+
+// packages/core/src/timeline.ts
+function finite(n) {
+  return typeof n === "number" && Number.isFinite(n);
+}
+function pickStreamingMeta(metadata) {
+  if (!metadata || typeof metadata !== "object") return void 0;
+  const chunkCount = metadata.chunkCount;
+  const streamDurationMs = metadata.streamDurationMs;
+  const streamedCharCount = metadata.streamedCharCount;
+  if (!finite(chunkCount) && !finite(streamDurationMs) && !finite(streamedCharCount)) {
+    return void 0;
+  }
+  return {
+    ...finite(chunkCount) ? { chunkCount } : {},
+    ...finite(streamDurationMs) ? { streamDurationMs } : {},
+    ...finite(streamedCharCount) ? { streamedCharCount } : {}
+  };
+}
+function pickCorrelation(metadata) {
+  if (!metadata || typeof metadata !== "object") return void 0;
+  const out = {};
+  for (const key of [
+    "correlationId",
+    "requestId",
+    "decisionId",
+    "groupId"
+  ]) {
+    const v = metadata[key];
+    if (typeof v === "string" && v.trim() !== "") {
+      out[key] = v;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function buildRunTimeline(events, options = {}) {
+  const started = events.find(
+    (e) => e.event === "run_started"
+  );
+  const completed = events.filter(
+    (e) => e.event === "run_completed"
+  );
+  const lastCompleted = completed[completed.length - 1];
+  const runId = started?.runId ?? events.find((e) => typeof e.runId === "string")?.runId ?? "unknown-run";
+  const runStart = started && finite(started.startTime) ? started.startTime : started && finite(started.timestamp) ? started.timestamp : void 0;
+  const status = lastCompleted ? lastCompleted.status : started ? "running" : "unknown";
+  const steps = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.event === "step_started") {
+      const s = e;
+      steps.set(s.stepId, {
+        name: s.name,
+        type: s.type,
+        parentId: s.parentId,
+        startedAt: finite(s.startTime) ? s.startTime : s.timestamp,
+        status: "running",
+        metadata: s.metadata
+      });
+    }
+  }
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const c = e;
+    const node = steps.get(c.stepId);
+    if (!node) continue;
+    node.status = c.status;
+    if (finite(c.durationMs)) node.durationMs = c.durationMs;
+  }
+  const depthCache = /* @__PURE__ */ new Map();
+  const computeDepth = (stepId) => {
+    const cached = depthCache.get(stepId);
+    if (cached !== void 0) return cached;
+    const node = steps.get(stepId);
+    if (!node) return 0;
+    const parent = node.parentId;
+    if (typeof parent !== "string" || parent.trim() === "" || !steps.has(parent)) {
+      depthCache.set(stepId, 0);
+      return 0;
+    }
+    const d = Math.min(1e3, computeDepth(parent) + 1);
+    depthCache.set(stepId, d);
+    return d;
+  };
+  const entries = [];
+  for (const [stepId, s] of steps.entries()) {
+    const offsetMs = runStart !== void 0 && finite(s.startedAt) ? Math.max(0, s.startedAt - runStart) : 0;
+    entries.push({
+      stepId,
+      name: s.name,
+      type: s.type,
+      status: s.status,
+      depth: computeDepth(stepId),
+      startedAt: s.startedAt,
+      offsetMs,
+      durationMs: s.durationMs,
+      isError: s.status === "error",
+      streaming: pickStreamingMeta(s.metadata)
+    });
+  }
+  entries.sort((a, b) => a.startedAt - b.startedAt);
+  const slowTopN = options.slowTopN ?? 3;
+  if (options.focus === "slow" && entries.length > 0) {
+    const ranked = [...entries].filter((e) => finite(e.durationMs)).sort((a, b) => (b.durationMs ?? 0) - (a.durationMs ?? 0));
+    const slowIds = new Set(
+      ranked.slice(0, slowTopN).map((e) => e.stepId)
+    );
+    for (const e of entries) {
+      if (slowIds.has(e.stepId)) e.slow = true;
+    }
+  }
+  return {
+    runId,
+    name: typeof started?.name === "string" && started.name.trim() !== "" ? started.name : void 0,
+    status,
+    startedAt: runStart,
+    endedAt: lastCompleted && finite(lastCompleted.endTime) ? lastCompleted.endTime : void 0,
+    durationMs: lastCompleted && finite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0,
+    correlation: pickCorrelation(
+      started?.metadata
+    ),
+    entries
+  };
+}
+function renderTimeline(timeline, options = {}) {
+  const lines = [];
+  lines.push(`Timeline: ${timeline.name ?? timeline.runId}`);
+  lines.push(`Run ID: ${timeline.runId}`);
+  lines.push(`Status: ${timeline.status}`);
+  if (timeline.startedAt !== void 0) {
+    lines.push(`Started: ${formatTimestamp(timeline.startedAt)}`);
+  }
+  if (timeline.durationMs !== void 0) {
+    lines.push(`Duration: ${formatDuration2(timeline.durationMs)}`);
+  }
+  if (timeline.correlation) {
+    const parts = Object.entries(timeline.correlation).filter(([, v]) => typeof v === "string").map(([k, v]) => `${k}=${v}`);
+    if (parts.length > 0) {
+      lines.push(`Correlation: ${parts.join(", ")}`);
+    }
+  }
+  lines.push("");
+  lines.push("Steps (chronological):");
+  const show = timeline.entries.filter((e) => {
+    if (options.focus === "slow") return e.slow === true;
+    return true;
+  });
+  if (show.length === 0) {
+    lines.push(
+      options.focus === "slow" ? "(no steps with duration for slow focus)" : "(no steps)"
+    );
+    return lines.join("\n");
+  }
+  for (const e of show) {
+    const prefix = e.slow ? "[slow] " : "";
+    const typeTag = e.type === "llm" ? "llm" : e.type === "tool" ? "tool" : e.type;
+    const dur = e.durationMs !== void 0 ? formatDuration2(e.durationMs) : "-";
+    const err = e.isError ? " error" : "";
+    const off = formatDuration2(e.offsetMs);
+    let line = `${prefix}+${off} ${typeTag}:${e.name} (${dur})${err}`;
+    if (e.streaming?.chunkCount !== void 0) {
+      line += ` chunks=${e.streaming.chunkCount}`;
+    }
+    if (e.streaming?.streamDurationMs !== void 0) {
+      line += ` stream=${formatDuration2(e.streaming.streamDurationMs)}`;
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return void 0;
+  const idx = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.ceil(p / 100 * sorted.length) - 1)
+  );
+  return sorted[idx];
+}
+async function readRunStartedMetadata(filePath) {
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    for (const line of raw.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (trimmed === "") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!isTraceEvent(parsed)) continue;
+      if (parsed.event !== "run_started") continue;
+      const rs = parsed;
+      if (rs.metadata && typeof rs.metadata === "object") {
+        return rs.metadata;
+      }
+      return void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function metaMatchesCorrelation(metadata, correlationId, groupId) {
+  if (correlationId) {
+    const v = metadata?.correlationId;
+    if (typeof v !== "string" || v !== correlationId) return false;
+  }
+  if (groupId) {
+    const v = metadata?.groupId;
+    if (typeof v !== "string" || v !== groupId) return false;
+  }
+  return true;
+}
+async function buildTraceStats(metas, options) {
+  let filtered = filterTraces(metas, { since: options.since });
+  if (options.correlationId || options.groupId) {
+    const next = [];
+    for (const m of filtered) {
+      const md = await readRunStartedMetadata(m.filePath);
+      if (metaMatchesCorrelation(md, options.correlationId, options.groupId)) {
+        next.push(m);
+      }
+    }
+    filtered = next;
+  }
+  let successCount = 0;
+  let errorCount = 0;
+  let runningCount = 0;
+  let unknownCount = 0;
+  const durations = [];
+  let totalSteps = 0;
+  let totalLlmSteps = 0;
+  let totalToolSteps = 0;
+  let totalErrorSteps = 0;
+  const slowestRuns = [];
+  const slowestSteps = [];
+  for (const m of filtered) {
+    if (m.status === "success") successCount += 1;
+    else if (m.status === "error") errorCount += 1;
+    else if (m.status === "running") runningCount += 1;
+    else unknownCount += 1;
+    if (typeof m.durationMs === "number" && Number.isFinite(m.durationMs) && m.durationMs >= 0) {
+      durations.push(m.durationMs);
+      slowestRuns.push({
+        runId: m.runId,
+        name: m.name,
+        durationMs: m.durationMs,
+        status: m.status
+      });
+    }
+    try {
+      const events = await readTraceEvents(m.runId, options.traceDir);
+      if (events.length === 0) continue;
+      const summary = buildRunSummary(events);
+      totalSteps += summary.totalSteps;
+      totalLlmSteps += summary.llmSteps;
+      totalToolSteps += summary.toolSteps;
+      totalErrorSteps += summary.errorSteps;
+      const steps = collectCompletedSteps(events, m.runId);
+      for (const s of steps) {
+        slowestSteps.push(s);
+      }
+    } catch {
+    }
+  }
+  slowestRuns.sort((a, b) => (b.durationMs ?? 0) - (a.durationMs ?? 0));
+  slowestSteps.sort((a, b) => b.durationMs - a.durationMs);
+  const runLimit = options.slowRunLimit ?? 5;
+  const stepLimit = options.slowStepLimit ?? 5;
+  const sortedDur = [...durations].sort((a, b) => a - b);
+  const totalRuns = filtered.length;
+  const errorRate = totalRuns > 0 ? errorCount / totalRuns : 0;
+  const sumDur = durations.reduce((a, b) => a + b, 0);
+  return {
+    traceDir: options.traceDir,
+    ...options.since ? { since: options.since } : {},
+    ...options.correlationId ? { correlationId: options.correlationId } : {},
+    ...options.groupId ? { groupId: options.groupId } : {},
+    totalRuns,
+    successCount,
+    errorCount,
+    runningCount,
+    unknownCount,
+    errorRate,
+    duration: {
+      ...sortedDur.length > 0 ? {
+        minMs: sortedDur[0],
+        maxMs: sortedDur[sortedDur.length - 1],
+        avgMs: sumDur / sortedDur.length,
+        p50Ms: percentile(sortedDur, 50),
+        p95Ms: percentile(sortedDur, 95)
+      } : {}
+    },
+    totalSteps,
+    avgStepsPerRun: totalRuns > 0 ? totalSteps / totalRuns : 0,
+    totalLlmSteps,
+    totalToolSteps,
+    totalErrorSteps,
+    slowestRuns: slowestRuns.slice(0, runLimit),
+    slowestSteps: slowestSteps.slice(0, stepLimit)
+  };
+}
+function collectCompletedSteps(events, runId) {
+  const started = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const e of events) {
+    if (e.event === "step_started") {
+      const s = e;
+      started.set(s.stepId, { name: s.name, type: s.type });
+    }
+    if (e.event === "step_completed") {
+      const c = e;
+      if (c.status !== "success" && c.status !== "error") continue;
+      if (typeof c.durationMs !== "number" || !Number.isFinite(c.durationMs)) {
+        continue;
+      }
+      const meta = started.get(c.stepId);
+      out.push({
+        runId,
+        stepName: meta?.name ?? c.stepId,
+        stepType: meta?.type ?? "logic",
+        durationMs: c.durationMs
+      });
+    }
+  }
+  return out;
+}
+function renderTraceStats(stats) {
+  const lines = [];
+  lines.push("Trace stats (local)");
+  lines.push(`Directory: ${stats.traceDir}`);
+  if (stats.since) lines.push(`Since: ${stats.since}`);
+  if (stats.correlationId) lines.push(`Correlation ID: ${stats.correlationId}`);
+  if (stats.groupId) lines.push(`Group ID: ${stats.groupId}`);
+  lines.push("");
+  lines.push(`Runs: ${stats.totalRuns}`);
+  lines.push(
+    `  success: ${stats.successCount}  error: ${stats.errorCount}  running: ${stats.runningCount}  unknown: ${stats.unknownCount}`
+  );
+  lines.push(`Error rate: ${(stats.errorRate * 100).toFixed(1)}%`);
+  if (stats.duration.avgMs !== void 0) {
+    lines.push(
+      `Duration: min ${formatDuration2(stats.duration.minMs ?? 0)} | avg ${formatDuration2(stats.duration.avgMs)} | p50 ${formatDuration2(stats.duration.p50Ms ?? 0)} | p95 ${formatDuration2(stats.duration.p95Ms ?? 0)} | max ${formatDuration2(stats.duration.maxMs ?? 0)}`
+    );
+  }
+  lines.push("");
+  lines.push(`Steps: ${stats.totalSteps} (avg ${stats.avgStepsPerRun.toFixed(1)} per run)`);
+  lines.push(
+    `  LLM: ${stats.totalLlmSteps}  tool: ${stats.totalToolSteps}  errors: ${stats.totalErrorSteps}`
+  );
+  if (stats.slowestRuns.length > 0) {
+    lines.push("");
+    lines.push("Slowest runs:");
+    for (const r of stats.slowestRuns) {
+      lines.push(
+        `  ${r.runId} | ${r.name ?? "-"} | ${formatDuration2(r.durationMs ?? 0)} | ${r.status}`
+      );
+    }
+  }
+  if (stats.slowestSteps.length > 0) {
+    lines.push("");
+    lines.push("Slowest steps:");
+    for (const s of stats.slowestSteps) {
+      lines.push(
+        `  ${s.runId} | ${s.stepType}:${s.stepName} | ${formatDuration2(s.durationMs)}`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
+// packages/core/src/search.ts
+function parseDurationFilter(expr) {
+  const raw = expr.trim();
+  const m = raw.match(/^(>=|<=|>|<)\s*(.+)$/);
+  if (!m) {
+    throw new Error(
+      `Invalid --duration "${expr}". Use forms like >5s, >=500ms, <2m.`
+    );
+  }
+  const op = m[1];
+  const ms = parseDuration(m[2].trim());
+  return { op, ms };
+}
+function durationMatches(valueMs, filter) {
+  if (valueMs === void 0 || !Number.isFinite(valueMs)) return false;
+  switch (filter.op) {
+    case ">":
+      return valueMs > filter.ms;
+    case ">=":
+      return valueMs >= filter.ms;
+    case "<":
+      return valueMs < filter.ms;
+    case "<=":
+      return valueMs <= filter.ms;
+    default:
+      return false;
+  }
+}
+function normalizeStepTypeFilter(kind, type) {
+  const v = (kind ?? type)?.trim().toLowerCase();
+  return v && v !== "" ? v : void 0;
+}
+function nameMatches(hay, needle) {
+  return hay.toLowerCase().includes(needle.toLowerCase());
+}
+async function searchTraces(metas, options) {
+  let filtered = filterTraces(metas, { since: options.since });
+  const stepTypeFilter = normalizeStepTypeFilter(options.kind, options.type);
+  const nameQuery = options.name?.trim();
+  const toolQuery = options.tool?.trim();
+  let durationFilter;
+  if (options.duration) {
+    durationFilter = parseDurationFilter(options.duration);
+  }
+  const limit = options.limit ?? 50;
+  const hasContentFilter = Boolean(
+    options.status || stepTypeFilter || nameQuery || toolQuery || durationFilter
+  );
+  const results = [];
+  if (!hasContentFilter) {
+    for (const m of filtered) {
+      results.push({
+        runId: m.runId,
+        runName: m.name,
+        runStatus: m.status,
+        timestamp: m.startedAt,
+        durationMs: m.durationMs,
+        matchReason: "trace in directory",
+        matchedFields: ["run"],
+        filePath: m.filePath
+      });
+    }
+    return results.slice(0, limit);
+  }
+  for (const m of filtered) {
+    if (options.status && m.status !== options.status) continue;
+    let events = [];
+    try {
+      events = await readTraceEvents(m.runId, options.traceDir);
+    } catch {
+      continue;
+    }
+    if (events.length === 0) continue;
+    const runMatches = matchRunLevel(m, {
+      stepTypeFilter,
+      nameQuery,
+      toolQuery,
+      durationFilter,
+      statusFilter: options.status
+    });
+    results.push(...runMatches);
+    const stepMatches = matchStepLevel(m, events, {
+      stepTypeFilter,
+      nameQuery,
+      toolQuery,
+      durationFilter,
+      statusFilter: options.status
+    });
+    results.push(...stepMatches);
+  }
+  results.sort((a, b) => {
+    const ta = a.timestamp ?? 0;
+    const tb = b.timestamp ?? 0;
+    if (ta !== tb) return ta - tb;
+    const runCmp = a.runId.localeCompare(b.runId);
+    if (runCmp !== 0) return runCmp;
+    return (a.stepName ?? "").localeCompare(b.stepName ?? "");
+  });
+  return results.slice(0, limit);
+}
+function matchRunLevel(m, opts) {
+  if (opts.stepTypeFilter || opts.toolQuery) return [];
+  const out = [];
+  const fields = [];
+  if (opts.statusFilter && m.status === opts.statusFilter) {
+    fields.push("run.status");
+  }
+  if (opts.nameQuery && nameMatches(m.name ?? m.runId, opts.nameQuery)) {
+    fields.push("run.name");
+  }
+  if (opts.durationFilter && durationMatches(m.durationMs, opts.durationFilter)) {
+    fields.push("run.durationMs");
+  }
+  if (fields.length === 0) return out;
+  out.push({
+    runId: m.runId,
+    runName: m.name,
+    runStatus: m.status,
+    timestamp: m.startedAt,
+    durationMs: m.durationMs,
+    matchReason: `run match: ${fields.join(", ")}`,
+    matchedFields: fields,
+    filePath: m.filePath
+  });
+  return out;
+}
+function matchStepLevel(m, events, opts) {
+  const out = [];
+  const started = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.event === "step_started") {
+      started.set(e.stepId, e);
+    }
+  }
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const c = e;
+    const s = started.get(c.stepId);
+    if (!s) continue;
+    const fields = [];
+    const stepType = s.type;
+    if (opts.stepTypeFilter && stepType !== opts.stepTypeFilter) {
+      continue;
+    }
+    const hasStepFilters = opts.stepTypeFilter || opts.nameQuery || opts.toolQuery || opts.durationFilter || opts.statusFilter === "error" || opts.statusFilter === "success";
+    if (!hasStepFilters) continue;
+    if (opts.statusFilter === "error" && c.status === "error") {
+      fields.push("step.status");
+    } else if (opts.statusFilter === "success" && c.status === "success") {
+      fields.push("step.status");
+    } else if (opts.statusFilter === "error" || opts.statusFilter === "success") {
+      continue;
+    }
+    if (opts.nameQuery) {
+      if (!nameMatches(s.name, opts.nameQuery)) continue;
+      fields.push("step.name");
+    }
+    if (opts.toolQuery) {
+      const toolName = typeof s.metadata?.toolName === "string" ? s.metadata.toolName : s.name;
+      if (!nameMatches(toolName, opts.toolQuery)) continue;
+      fields.push("step.tool");
+    }
+    if (opts.durationFilter) {
+      if (!durationMatches(c.durationMs, opts.durationFilter)) continue;
+      fields.push("step.durationMs");
+    }
+    if (opts.stepTypeFilter) {
+      fields.push("step.type");
+    }
+    if (fields.length === 0) continue;
+    out.push({
+      runId: m.runId,
+      runName: m.name,
+      runStatus: m.status,
+      stepId: c.stepId,
+      stepName: s.name,
+      stepType,
+      timestamp: s.startTime ?? s.timestamp,
+      durationMs: c.durationMs,
+      matchReason: `step match: ${fields.join(", ")}`,
+      matchedFields: fields,
+      filePath: m.filePath
+    });
+  }
+  return out;
+}
+async function loadTraceMetadataList(_traceDir, fileNames, getPath) {
+  const metas = [];
+  for (const fileName of fileNames) {
+    try {
+      const filePath = getPath(fileName);
+      const meta = await extractMetadata(filePath);
+      metas.push(meta);
+    } catch {
+    }
+  }
+  return metas;
+}
 var KNOWN_EVENTS = /* @__PURE__ */ new Set([
   "run_started",
   "run_completed",
@@ -3207,6 +3885,134 @@ Object.assign(stepImpl, {
 // packages/core/src/exporters/types.ts
 var EXPORT_PAYLOAD_VERSION = "0.1.2";
 
+// packages/core/src/exporters/redact-export.ts
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepClone(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClone(item));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    out[k] = deepClone(v);
+  }
+  return out;
+}
+function boundAttributeValues(record, maxMetadataValueLength, maxPreviewLength, seen, depth) {
+  if (depth > 32) {
+    return { truncated: true, reason: "maxDepth" };
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(record)) {
+    out[key] = boundValue(value, key, maxMetadataValueLength, maxPreviewLength, seen, depth);
+  }
+  return out;
+}
+function boundValue(value, key, maxMetadataValueLength, maxPreviewLength, seen, depth) {
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "string") {
+      return truncateStringForProfile(
+        value,
+        key,
+        maxMetadataValueLength,
+        maxPreviewLength
+      );
+    }
+    return value;
+  }
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.slice(0, 50).map(
+      (item, index) => boundValue(
+        item,
+        String(index),
+        maxMetadataValueLength,
+        maxPreviewLength,
+        seen,
+        depth + 1
+      )
+    );
+  }
+  return boundAttributeValues(
+    value,
+    maxMetadataValueLength,
+    maxPreviewLength,
+    seen,
+    depth + 1
+  );
+}
+function redactEventAttributes(attrs, redactor, maxMetadataValueLength, maxPreviewLength) {
+  if (!attrs || Object.keys(attrs).length === 0) {
+    return attrs;
+  }
+  const redacted = redactor.redactRecord(attrs);
+  const seen = /* @__PURE__ */ new WeakSet();
+  const bounded = boundAttributeValues(
+    redacted,
+    maxMetadataValueLength,
+    maxPreviewLength,
+    seen,
+    0
+  );
+  const err = bounded.error;
+  if (isRecord9(err) && typeof err.message === "string") {
+    bounded.error = {
+      ...err,
+      message: truncateStringForProfile(
+        err.message,
+        "message",
+        maxMetadataValueLength,
+        maxPreviewLength
+      ),
+      ...typeof err.stack === "string" ? {
+        stack: truncateStringForProfile(
+          err.stack,
+          "stack",
+          maxMetadataValueLength,
+          maxPreviewLength
+        )
+      } : {}
+    };
+  }
+  return bounded;
+}
+function redactRunTreeForExport(tree, options) {
+  const profile = options?.redactionProfile ?? "local";
+  if (profile === "local") {
+    return deepClone(tree);
+  }
+  const resolved = resolveRedactionProfile(profile);
+  const { maxMetadataValueLength, maxPreviewLength } = applyProfileMetadataCaps(
+    2e3,
+    500,
+    resolved
+  );
+  const redactor = new Redactor({ extraKeys: resolved.extraKeys });
+  const clone = deepClone(tree);
+  function walk(nodes) {
+    for (const node of nodes) {
+      if (node.event.attributes !== void 0) {
+        node.event.attributes = redactEventAttributes(
+          node.event.attributes,
+          redactor,
+          maxMetadataValueLength,
+          maxPreviewLength
+        );
+      }
+      if (node.children.length > 0) {
+        walk(node.children);
+      }
+    }
+  }
+  walk(clone.children);
+  return clone;
+}
+
 // packages/core/src/exporters/html-exporter.ts
 function renderTreeHtml(nodes, ulClass = "tree") {
   if (nodes.length === 0) return "";
@@ -3941,20 +4747,22 @@ function mergeExportDefaults(options) {
     includeErrors: options.includeErrors ?? true,
     pretty: options.pretty,
     redacted: options.redacted,
-    maxAttributeLength: options.maxAttributeLength
+    maxAttributeLength: options.maxAttributeLength,
+    redactionProfile: options.redactionProfile ?? "local"
   };
 }
 function exportRunTree(tree, options) {
   const opts = mergeExportDefaults(options);
+  const exportTree = opts.redactionProfile === "local" ? tree : redactRunTreeForExport(tree, { redactionProfile: opts.redactionProfile });
   switch (opts.format) {
     case "markdown":
-      return exportMarkdown(tree, opts);
+      return exportMarkdown(exportTree, opts);
     case "html":
-      return exportHtml(tree, opts);
+      return exportHtml(exportTree, opts);
     case "openinference":
-      return exportOpenInference(tree, opts);
+      return exportOpenInference(exportTree, opts);
     case "otlp-json":
-      return exportOtlpJson(tree, opts);
+      return exportOtlpJson(exportTree, opts);
     default: {
       const _x = opts.format;
       throw new Error(`Unsupported export format: ${String(_x)}`);
@@ -4790,6 +5598,15 @@ async function tail(options = {}) {
     process.exitCode = 1;
   }
 }
+function parseRedactionProfile(s) {
+  const v = (s ?? "local").trim().toLowerCase();
+  if (v === "local" || v === "share" || v === "strict") {
+    return v;
+  }
+  throw new Error(
+    `Unsupported --redaction-profile "${s ?? ""}". Use local, share, or strict.`
+  );
+}
 function parseExportFormat(s) {
   const v = (s ?? "markdown").trim().toLowerCase();
   if (v === "markdown" || v === "html" || v === "openinference" || v === "otlp-json") {
@@ -4807,8 +5624,10 @@ async function exportCommand(runId, options = {}) {
     return;
   }
   let format;
+  let redactionProfile;
   try {
     format = parseExportFormat(options.format);
+    redactionProfile = parseRedactionProfile(options.redactionProfile);
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     console.error(msg);
@@ -4847,7 +5666,8 @@ Trace directory: ${traceDir}`);
     includeErrors: options.noErrors === true ? false : true,
     pretty: true,
     redacted: true,
-    maxAttributeLength: 500
+    maxAttributeLength: 500,
+    redactionProfile
   };
   const result = exportRunTree(tree, exportOpts);
   const validation = options.validate === true ? validateExport(result) : void 0;
@@ -4996,6 +5816,163 @@ Trace directory: ${traceDir}`
   );
 }
 
+// packages/cli/src/timeline.ts
+async function timelineCommand(runId, options = {}) {
+  const id = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "";
+  if (id === "") {
+    console.error("Run id is required");
+    process.exitCode = 1;
+    return;
+  }
+  const traceDir = resolveTraceDir({ dir: options.dir });
+  let events;
+  try {
+    events = await readTraceEvents(id, traceDir);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`[AgentInspect] timeline failed: ${msg}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (events.length === 0) {
+    console.log(`Run not found: ${id}`);
+    console.log(`Trace directory: ${traceDir}`);
+    process.exitCode = 1;
+    return;
+  }
+  const focus = options.focus?.trim().toLowerCase() === "slow" ? "slow" : "all";
+  const timeline = buildRunTimeline(events, {
+    focus: focus === "slow" ? "slow" : "all"
+  });
+  if (options.json) {
+    console.log(JSON.stringify(timeline, null, 2));
+    return;
+  }
+  console.log(renderTimeline(timeline, { focus }));
+}
+
+// packages/cli/src/stats.ts
+async function statsCommand(options = {}) {
+  try {
+    const traceDir = resolveTraceDir({ dir: options.dir });
+    const td = new TraceDirectory({ dir: traceDir });
+    if (typeof options.since === "string" && options.since.trim() !== "") {
+      parseDuration(options.since.trim());
+    }
+    const files = await td.list();
+    if (files.length === 0) {
+      if (options.json) {
+        console.log(
+          JSON.stringify({
+            traceDir,
+            totalRuns: 0,
+            successCount: 0,
+            errorCount: 0,
+            runningCount: 0,
+            unknownCount: 0,
+            errorRate: 0,
+            duration: {},
+            totalSteps: 0,
+            avgStepsPerRun: 0,
+            totalLlmSteps: 0,
+            totalToolSteps: 0,
+            totalErrorSteps: 0,
+            slowestRuns: [],
+            slowestSteps: []
+          })
+        );
+      } else {
+        console.log("No AgentInspect runs found");
+        console.log(`Trace directory: ${traceDir}`);
+      }
+      return;
+    }
+    const metas = [];
+    for (const fileName of files) {
+      try {
+        metas.push(await extractMetadata(td.getPath(fileName)));
+      } catch {
+      }
+    }
+    const stats = await buildTraceStats(metas, {
+      traceDir,
+      since: options.since,
+      correlationId: options.correlationId,
+      groupId: options.groupId
+    });
+    if (options.json) {
+      console.log(JSON.stringify(stats, null, 2));
+      return;
+    }
+    console.log(renderTraceStats(stats));
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`[AgentInspect] stats failed: ${msg}`);
+    process.exitCode = 1;
+  }
+}
+
+// packages/cli/src/search.ts
+function parseLimit2(raw) {
+  if (raw === void 0 || raw.trim() === "") return 50;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) return 50;
+  return Math.min(n, 500);
+}
+async function searchCommand(options = {}) {
+  try {
+    const traceDir = resolveTraceDir({ dir: options.dir });
+    const td = new TraceDirectory({ dir: traceDir });
+    if (typeof options.since === "string" && options.since.trim() !== "") {
+      parseDuration(options.since.trim());
+    }
+    if (options.duration) {
+      parseDurationFilter(options.duration);
+    }
+    const files = await td.list();
+    const metas = await loadTraceMetadataList(
+      traceDir,
+      files,
+      (f) => td.getPath(f)
+    );
+    const status = options.status === "success" || options.status === "error" || options.status === "running" || options.status === "unknown" ? options.status : void 0;
+    const results = await searchTraces(metas, {
+      traceDir,
+      since: options.since,
+      status,
+      kind: options.kind,
+      type: options.type,
+      name: options.name,
+      tool: options.tool,
+      duration: options.duration,
+      limit: parseLimit2(options.limit)
+    });
+    if (options.json) {
+      console.log(JSON.stringify(results, null, 2));
+      return;
+    }
+    if (results.length === 0) {
+      console.log("No matching traces found");
+      console.log(`Trace directory: ${traceDir}`);
+      return;
+    }
+    console.log(`Search results (${results.length})`);
+    for (const r of results) {
+      const step2 = r.stepName !== void 0 ? ` | ${r.stepType ?? "step"}:${r.stepName}` : "";
+      const dur = r.durationMs !== void 0 ? ` | ${r.durationMs}ms` : "";
+      console.log(
+        `${r.runId}${step2} | ${r.runStatus}${dur} | ${r.matchReason}`
+      );
+    }
+    console.log("");
+    console.log(`Trace directory: ${traceDir}`);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`[AgentInspect] search failed: ${msg}`);
+    process.exitCode = 1;
+  }
+}
+
 // packages/cli/src/index.ts
 function runCommand(action) {
   void action().catch((error) => {
@@ -5080,7 +6057,12 @@ function createCliProgram() {
       "openinference",
       "otlp-json"
     ])
-  ).option("-o, --output <path>", "write export to file (creates parent dirs)").option("--json", "emit JSON wrapper about the export (includes content when writing to stdout)").option("--validate", "validate exported payload shape after generation").option("--include-attributes", "include bounded attributes (review before sharing)").option("--no-metadata", "omit summary / metadata sections").option("--no-errors", "omit error sections").action((runId, opts) => {
+  ).option("-o, --output <path>", "write export to file (creates parent dirs)").option("--json", "emit JSON wrapper about the export (includes content when writing to stdout)").option("--validate", "validate exported payload shape after generation").option("--include-attributes", "include bounded attributes (review before sharing)").option("--no-metadata", "omit summary / metadata sections").option("--no-errors", "omit error sections").addOption(
+    new Option(
+      "--redaction-profile <profile>",
+      "redaction profile for exported copies: local, share, strict (default: local)"
+    ).choices(["local", "share", "strict"])
+  ).action((runId, opts) => {
     runCommand(() => exportCommand(runId, opts));
   });
   program.command("diff").description("Compare two local AgentInspect JSONL traces (read-only)").argument("<left-run-id>", "first run id").argument("<right-run-id>", "second run id").option("--dir <path>", "trace directory").option("--json", "print diff result as JSON").option("--ignore-duration", "omit duration comparisons").option(
@@ -5104,6 +6086,29 @@ function createCliProgram() {
   ).option("--verbose", "show more left/right detail").action((leftRunId, rightRunId, opts) => {
     runCommand(() => diffCommand(leftRunId, rightRunId, opts));
   });
+  program.command("timeline").description("Chronological timeline for a single run (local JSONL)").argument("<run-id>", "run id (e.g. from list output)").option("--dir <path>", "trace directory").option("--json", "print timeline as JSON").addOption(
+    new Option("--focus <mode>", "highlight slowest steps by duration").choices([
+      "slow"
+    ])
+  ).action((runId, opts) => {
+    runCommand(() => timelineCommand(runId, opts));
+  });
+  program.command("stats").description("Local aggregate stats over trace files (read-only)").option("--dir <path>", "trace directory").option("--since <duration>", "only include runs since a duration (e.g. 7d)").option("--correlation-id <id>", "filter by run_started.metadata.correlationId").option("--group-id <id>", "filter by run_started.metadata.groupId").option("--json", "print stats as JSON").action((opts) => {
+    runCommand(() => statsCommand(opts));
+  });
+  program.command("search").description("Deterministic local search over trace files (read-only)").option("--dir <path>", "trace directory").option("--since <duration>", "only search runs since a duration").addOption(
+    new Option("--status <status>", "filter by run or step status").choices([
+      "success",
+      "error",
+      "running",
+      "unknown"
+    ])
+  ).option("--kind <kind>", "filter by step kind/type (llm, tool, logic, \u2026)").option("--type <type>", "alias for --kind on manual trace step type").option("--name <query>", "substring match on run or step name").option("--tool <query>", "substring match on tool step name or metadata.toolName").option(
+    "--duration <expr>",
+    "duration filter on run or step (e.g. >5s, >=500ms)"
+  ).option("--limit <number>", "max results (default 50)").option("--json", "print results as JSON").action((opts) => {
+    runCommand(() => searchCommand(opts));
+  });
   return program;
 }
 function isPrimaryModule() {