agent-inspect 4.0.0 → 4.1.0

package/packages/cli/dist/index.cjs

@@ -1,39 +1,69 @@
 #!/usr/bin/env node
 'use strict';
 
-var fs = require('fs');
-var path14 = require('path');
-var url = require('url');
-var commander = require('commander');
-var async_hooks = require('async_hooks');
 var crypto = require('crypto');
 var promises = require('fs/promises');
 var os = require('os');
+var path14 = require('path');
+var async_hooks = require('async_hooks');
 var process3 = require('process');
 var tty = require('tty');
+var fs = require('fs');
 var readline = require('readline');
+var url = require('url');
+var commander = require('commander');
 var http = require('http');
 var module$1 = require('module');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var path14__default = /*#__PURE__*/_interopDefault(path14);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var os__default = /*#__PURE__*/_interopDefault(os);
+var path14__default = /*#__PURE__*/_interopDefault(path14);
 var process3__default = /*#__PURE__*/_interopDefault(process3);
 var tty__default = /*#__PURE__*/_interopDefault(tty);
 
-// package.json
-var version = "4.0.0";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
 
 // packages/core/src/correlation-metadata.ts
-var TRACE_CORRELATION_KEYS = [
-  "correlationId",
-  "requestId",
-  "decisionId",
-  "groupId"
-];
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
 }
@@ -52,15 +82,17 @@ function extractCorrelationMetadata(record) {
   }
   return found ? out : void 0;
 }
-var DEFAULT_REDACT_KEYS = [
-  "authorization",
-  "cookie",
-  "token",
-  "apiKey",
-  "password",
-  "secret",
-  "email"
-];
+var TRACE_CORRELATION_KEYS;
+var init_correlation_metadata = __esm({
+  "packages/core/src/correlation-metadata.ts"() {
+    TRACE_CORRELATION_KEYS = [
+      "correlationId",
+      "requestId",
+      "decisionId",
+      "groupId"
+    ];
+  }
+});
 function isRecord(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -99,94 +131,67 @@ function compileRules(rules, extraKeys) {
   }
   return [...out.values()];
 }
-var Redactor = class {
-  #rules;
-  constructor(options) {
-    this.#rules = compileRules(options?.rules, options?.extraKeys);
-  }
-  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 (isRecord(value)) {
-      const out = {};
-      for (const [k, v] of Object.entries(value)) {
-        out[k] = this.redactValue(k, v);
+var DEFAULT_REDACT_KEYS, Redactor;
+var init_redactor = __esm({
+  "packages/core/src/logs/redactor.ts"() {
+    DEFAULT_REDACT_KEYS = [
+      "authorization",
+      "cookie",
+      "token",
+      "apiKey",
+      "password",
+      "secret",
+      "email"
+    ];
+    Redactor = class {
+      #rules;
+      constructor(options) {
+        this.#rules = compileRules(options?.rules, options?.extraKeys);
       }
-      return out;
-    }
-    return value;
+      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 (isRecord(value)) {
+          const out = {};
+          for (const [k, v] of Object.entries(value)) {
+            out[k] = this.redactValue(k, v);
+          }
+          return out;
+        }
+        return value;
+      }
+    };
   }
-};
+});
 
 // 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":
@@ -213,15 +218,15 @@ function isPreviewKey(key) {
   return key.toLowerCase().includes("preview");
 }
 function applyProfileMetadataCaps(maxMetadataValueLength, maxPreviewLength, resolved) {
-  let meta = maxMetadataValueLength;
+  let meta2 = maxMetadataValueLength;
   let preview = maxPreviewLength;
   if (resolved.maxMetadataValueLengthCap !== void 0) {
-    meta = Math.min(meta, resolved.maxMetadataValueLengthCap);
+    meta2 = Math.min(meta2, resolved.maxMetadataValueLengthCap);
   }
   if (resolved.maxPreviewLengthCap !== void 0) {
     preview = Math.min(preview, resolved.maxPreviewLengthCap);
   }
-  return { maxMetadataValueLength: meta, maxPreviewLength: preview };
+  return { maxMetadataValueLength: meta2, maxPreviewLength: preview };
 }
 function truncateStringForProfile(value, key, maxMetadataValueLength, maxPreviewLength) {
   const max = isPreviewKey(key) ? maxPreviewLength : maxMetadataValueLength;
@@ -229,17 +234,54 @@ function truncateStringForProfile(value, key, maxMetadataValueLength, maxPreview
   if (value.length <= max) return value;
   return `${value.slice(0, max)}\u2026`;
 }
+var SHARE_PROFILE_EXTRA_KEYS, STRICT_PROFILE_EXTRA_KEYS;
+var init_redaction_profiles = __esm({
+  "packages/core/src/redaction-profiles.ts"() {
+    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"
+    ];
+    STRICT_PROFILE_EXTRA_KEYS = [
+      "prompt",
+      "completion",
+      "input",
+      "output",
+      "inputPreview",
+      "outputPreview",
+      "message",
+      "messages",
+      "transcript",
+      "context",
+      "document",
+      "documents",
+      "chunk",
+      "chunks",
+      "retrieval",
+      "query"
+    ];
+  }
+});
 
 // packages/core/src/types.ts
-var STEP_TYPES = [
-  "run",
-  "llm",
-  "tool",
-  "decision",
-  "logic",
-  "state",
-  "custom"
-];
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -268,41 +310,22 @@ function isTraceEvent(value) {
       return false;
   }
 }
+var STEP_TYPES;
+var init_types = __esm({
+  "packages/core/src/types.ts"() {
+    STEP_TYPES = [
+      "run",
+      "llm",
+      "tool",
+      "decision",
+      "logic",
+      "state",
+      "custom"
+    ];
+  }
+});
 
 // packages/core/src/types/persisted-inspect-event.ts
-var INSPECT_KINDS = [
-  "RUN",
-  "AGENT",
-  "LLM",
-  "TOOL",
-  "CHAIN",
-  "RETRIEVER",
-  "DECISION",
-  "RESULT",
-  "ERROR",
-  "LOGIC",
-  "LOG"
-];
-var ATTRIBUTION_CONFIDENCES = [
-  "explicit",
-  "correlated",
-  "heuristic",
-  "unknown"
-];
-var PERSISTED_EVENT_SOURCE_TYPES = [
-  "manual",
-  "json-log",
-  "log4js",
-  "adapter",
-  "ai-sdk",
-  "otel"
-];
-var PERSISTED_EVENT_STATUSES = [
-  "running",
-  "ok",
-  "error",
-  "unknown"
-];
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -399,6 +422,44 @@ function isPersistedInspectEvent(value) {
   }
   return true;
 }
+var INSPECT_KINDS, ATTRIBUTION_CONFIDENCES, PERSISTED_EVENT_SOURCE_TYPES, PERSISTED_EVENT_STATUSES;
+var init_persisted_inspect_event = __esm({
+  "packages/core/src/types/persisted-inspect-event.ts"() {
+    INSPECT_KINDS = [
+      "RUN",
+      "AGENT",
+      "LLM",
+      "TOOL",
+      "CHAIN",
+      "RETRIEVER",
+      "DECISION",
+      "RESULT",
+      "ERROR",
+      "LOGIC",
+      "LOG"
+    ];
+    ATTRIBUTION_CONFIDENCES = [
+      "explicit",
+      "correlated",
+      "heuristic",
+      "unknown"
+    ];
+    PERSISTED_EVENT_SOURCE_TYPES = [
+      "manual",
+      "json-log",
+      "log4js",
+      "adapter",
+      "ai-sdk",
+      "otel"
+    ];
+    PERSISTED_EVENT_STATUSES = [
+      "running",
+      "ok",
+      "error",
+      "unknown"
+    ];
+  }
+});
 
 // packages/core/src/persisted/to-trace-event.ts
 function parseIsoToMs(iso) {
@@ -674,14 +735,19 @@ function persistedInspectEventsToTraceEvents(events, options) {
   });
   return out;
 }
+var init_to_trace_event = __esm({
+  "packages/core/src/persisted/to-trace-event.ts"() {
+    init_persisted_inspect_event();
+  }
+});
 
 // node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/url-alphabet/index.js
-var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-
-// node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/index.js
-var POOL_SIZE_MULTIPLIER = 128;
-var pool;
-var poolOffset;
+var urlAlphabet;
+var init_url_alphabet = __esm({
+  "node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/url-alphabet/index.js"() {
+    urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+  }
+});
 function fillPool(bytes) {
   if (bytes < 0 || bytes > 1024) throw new RangeError("Wrong ID size");
   if (!pool || pool.length < bytes) {
@@ -702,6 +768,13 @@ function nanoid(size = 21) {
   }
   return id;
 }
+var POOL_SIZE_MULTIPLIER, pool, poolOffset;
+var init_nanoid = __esm({
+  "node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/index.js"() {
+    init_url_alphabet();
+    POOL_SIZE_MULTIPLIER = 128;
+  }
+});
 
 // packages/core/src/utils/duration.ts
 function parseDuration(duration) {
@@ -753,16 +826,10 @@ function formatDuration(ms) {
   }
   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 = path14__default.default.join(
-  os__default.default.tmpdir(),
-  "agent-inspect",
-  RUNS_DIR_NAME
-);
-var MAX_NAME_LENGTH = 100;
+var init_duration = __esm({
+  "packages/core/src/utils/duration.ts"() {
+  }
+});
 function formatDuration2(ms) {
   return formatDuration(ms);
 }
@@ -855,6 +922,20 @@ function warn(message, error) {
   }
   console.warn(`${base}: ${formatError(error).message}`);
 }
+var DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME, FALLBACK_TRACE_DIR, MAX_NAME_LENGTH;
+var init_utils = __esm({
+  "packages/core/src/utils.ts"() {
+    init_duration();
+    DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
+    RUNS_DIR_NAME = "runs";
+    FALLBACK_TRACE_DIR = path14__default.default.join(
+      os__default.default.tmpdir(),
+      "agent-inspect",
+      RUNS_DIR_NAME
+    );
+    MAX_NAME_LENGTH = 100;
+  }
+});
 
 // packages/core/src/read-trace.ts
 function isRecord4(value) {
@@ -931,8 +1012,14 @@ function parseTraceJsonl(raw, options = {}) {
   else if (saw10) format = "1.0";
   return { format, sourceEventCount, events: traceEvents, persisted, rows };
 }
-
-// packages/core/src/storage.ts
+var init_read_trace = __esm({
+  "packages/core/src/read-trace.ts"() {
+    init_to_trace_event();
+    init_persisted_inspect_event();
+    init_types();
+    init_utils();
+  }
+});
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1000,79 +1087,48 @@ async function readTraceEventsFromFile(filePath) {
     return [];
   }
 }
+var init_storage = __esm({
+  "packages/core/src/storage.ts"() {
+    init_types();
+    init_trace_event_safety();
+    init_read_trace();
+    init_utils();
+  }
+});
 
-// packages/core/src/context.ts
-new async_hooks.AsyncLocalStorage();
+// packages/core/src/trace-event-safety.ts
+var init_trace_event_safety = __esm({
+  "packages/core/src/trace-event-safety.ts"() {
+    init_redactor();
+    init_redaction_profiles();
+    init_storage();
+    init_persisted_inspect_event();
+  }
+});
+var init_context = __esm({
+  "packages/core/src/context.ts"() {
+    init_correlation_metadata();
+    init_trace_event_safety();
+    new async_hooks.AsyncLocalStorage();
+  }
+});
+var init_inspector_runtime = __esm({
+  "packages/core/src/inspector-runtime.ts"() {
+    init_correlation_metadata();
+    init_trace_event_safety();
+  }
+});
 
-// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    // 21 isn't widely supported and 22 does the same thing
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    // Bright color
-    blackBright: [90, 39],
-    gray: [90, 39],
-    // Alias of `blackBright`
-    grey: [90, 39],
-    // Alias of `blackBright`
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    // Bright color
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    // Alias of `bgBlackBright`
-    bgGrey: [100, 49],
-    // Alias of `bgBlackBright`
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
+// packages/core/src/inspector.ts
+var init_inspector = __esm({
+  "packages/core/src/inspector.ts"() {
+    init_inspector_runtime();
+    init_trace_event_safety();
+    init_utils();
   }
-};
-Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-[...foregroundColorNames, ...backgroundColorNames];
+});
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 function assembleStyles() {
   const codes = /* @__PURE__ */ new Map();
   for (const [groupName, group] of Object.entries(styles)) {
@@ -1187,21 +1243,87 @@ function assembleStyles() {
   });
   return styles;
 }
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
+var ANSI_BACKGROUND_OFFSET, wrapAnsi16, wrapAnsi256, wrapAnsi16m, styles, foregroundColorNames, backgroundColorNames, ansiStyles, ansi_styles_default;
+var init_ansi_styles = __esm({
+  "node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js"() {
+    ANSI_BACKGROUND_OFFSET = 10;
+    wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+    wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+    wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+    styles = {
+      modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        gray: [90, 39],
+        // Alias of `blackBright`
+        grey: [90, 39],
+        // Alias of `blackBright`
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgGray: [100, 49],
+        // Alias of `bgBlackBright`
+        bgGrey: [100, 49],
+        // Alias of `bgBlackBright`
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    Object.keys(styles.modifier);
+    foregroundColorNames = Object.keys(styles.color);
+    backgroundColorNames = Object.keys(styles.bgColor);
+    [...foregroundColorNames, ...backgroundColorNames];
+    ansiStyles = assembleStyles();
+    ansi_styles_default = ansiStyles;
+  }
+});
 function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process3__default.default.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
   const position = argv.indexOf(prefix + flag);
   const terminatorPosition = argv.indexOf("--");
   return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
-var { env } = process3__default.default;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
 function envForceColor() {
   if ("FORCE_COLOR" in env) {
     if (env.FORCE_COLOR === "true") {
@@ -1311,11 +1433,22 @@ function createSupportsColor(stream, options = {}) {
   });
   return translateLevel(level);
 }
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty__default.default.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty__default.default.isatty(2) })
-};
-var supports_color_default = supportsColor;
+var env, flagForceColor, supportsColor, supports_color_default;
+var init_supports_color = __esm({
+  "node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js"() {
+    ({ env } = process3__default.default);
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      flagForceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      flagForceColor = 1;
+    }
+    supportsColor = {
+      stdout: createSupportsColor({ isTTY: tty__default.default.isatty(1) }),
+      stderr: createSupportsColor({ isTTY: tty__default.default.isatty(2) })
+    };
+    supports_color_default = supportsColor;
+  }
+});
 
 // node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
 function stringReplaceAll(string, substring, replacer) {
@@ -1346,158 +1479,167 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
   returnValue += string.slice(endIndex);
   return returnValue;
 }
+var init_utilities = __esm({
+  "node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js"() {
+  }
+});
 
 // node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
-var STYLER = /* @__PURE__ */ Symbol("STYLER");
-var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = /* @__PURE__ */ Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === void 0 ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk2 = (...strings) => strings.join(" ");
-  applyOptions(chalk2, options);
-  Object.setPrototypeOf(chalk2, createChalk.prototype);
-  return chalk2;
-};
 function createChalk(options) {
   return chalkFactory(options);
 }
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
-    }
-  };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
+var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2, applyOptions, chalkFactory, getModelAnsi, usedModels, proto, createStyler, createBuilder, applyStyle, chalk, source_default;
+var init_source = __esm({
+  "node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js"() {
+    init_ansi_styles();
+    init_supports_color();
+    init_utilities();
+    ({ stdout: stdoutColor, stderr: stderrColor } = supports_color_default);
+    GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+    STYLER = /* @__PURE__ */ Symbol("STYLER");
+    IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+    levelMapping = [
+      "ansi",
+      "ansi",
+      "ansi256",
+      "ansi16m"
+    ];
+    styles2 = /* @__PURE__ */ Object.create(null);
+    applyOptions = (object, options = {}) => {
+      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+        throw new Error("The `level` option should be an integer from 0 to 3");
+      }
+      const colorLevel = stdoutColor ? stdoutColor.level : 0;
+      object.level = options.level === void 0 ? colorLevel : options.level;
+    };
+    chalkFactory = (options) => {
+      const chalk2 = (...strings) => strings.join(" ");
+      applyOptions(chalk2, options);
+      Object.setPrototypeOf(chalk2, createChalk.prototype);
+      return chalk2;
+    };
+    Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+    for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+      styles2[styleName] = {
+        get() {
+          const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+          Object.defineProperty(this, styleName, { value: builder });
+          return builder;
+        }
       };
     }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
+    styles2.visible = {
+      get() {
+        const builder = createBuilder(this, this[STYLER], true);
+        Object.defineProperty(this, "visible", { value: builder });
+        return builder;
+      }
+    };
+    getModelAnsi = (model, level, type, ...arguments_) => {
+      if (model === "rgb") {
+        if (level === "ansi16m") {
+          return ansi_styles_default[type].ansi16m(...arguments_);
+        }
+        if (level === "ansi256") {
+          return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+        }
+        return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+      }
+      if (model === "hex") {
+        return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+      }
+      return ansi_styles_default[type][model](...arguments_);
+    };
+    usedModels = ["rgb", "hex", "ansi256"];
+    for (const model of usedModels) {
+      styles2[model] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles2[bgModel] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
       };
     }
-  };
-}
-var proto = Object.defineProperties(() => {
-}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
-    }
+    proto = Object.defineProperties(() => {
+    }, {
+      ...styles2,
+      level: {
+        enumerable: true,
+        get() {
+          return this[GENERATOR].level;
+        },
+        set(level) {
+          this[GENERATOR].level = level;
+        }
+      }
+    });
+    createStyler = (open3, close, parent) => {
+      let openAll;
+      let closeAll;
+      if (parent === void 0) {
+        openAll = open3;
+        closeAll = close;
+      } else {
+        openAll = parent.openAll + open3;
+        closeAll = close + parent.closeAll;
+      }
+      return {
+        open: open3,
+        close,
+        openAll,
+        closeAll,
+        parent
+      };
+    };
+    createBuilder = (self, _styler, _isEmpty) => {
+      const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+      Object.setPrototypeOf(builder, proto);
+      builder[GENERATOR] = self;
+      builder[STYLER] = _styler;
+      builder[IS_EMPTY] = _isEmpty;
+      return builder;
+    };
+    applyStyle = (self, string) => {
+      if (self.level <= 0 || !string) {
+        return self[IS_EMPTY] ? "" : string;
+      }
+      let styler = self[STYLER];
+      if (styler === void 0) {
+        return string;
+      }
+      const { openAll, closeAll } = styler;
+      if (string.includes("\x1B")) {
+        while (styler !== void 0) {
+          string = stringReplaceAll(string, styler.close, styler.open);
+          styler = styler.parent;
+        }
+      }
+      const lfIndex = string.indexOf("\n");
+      if (lfIndex !== -1) {
+        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+      }
+      return openAll + string + closeAll;
+    };
+    Object.defineProperties(createChalk.prototype, styles2);
+    chalk = createChalk();
+    createChalk({ level: stderrColor ? stderrColor.level : 0 });
+    source_default = chalk;
   }
 });
-var createStyler = (open3, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === void 0) {
-    openAll = open3;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open3;
-    closeAll = close + parent.closeAll;
-  }
-  return {
-    open: open3,
-    close,
-    openAll,
-    closeAll,
-    parent
-  };
-};
-var createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
-    return self[IS_EMPTY] ? "" : string;
-  }
-  let styler = self[STYLER];
-  if (styler === void 0) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== void 0) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
-    }
-  }
-  const lfIndex = string.indexOf("\n");
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
 
 // packages/core/src/terminal.ts
-var TERMINAL_INDENT = "  ";
-var MAX_TERMINAL_NAME_LENGTH = 80;
-var MAX_TERMINAL_DEPTH = 10;
 function normalizeDepth(depth) {
   if (!Number.isFinite(depth) || depth < 0) {
     return 0;
@@ -1550,6 +1692,17 @@ function renderErrorLine(error, depth) {
     return "";
   }
 }
+var TERMINAL_INDENT, MAX_TERMINAL_NAME_LENGTH, MAX_TERMINAL_DEPTH;
+var init_terminal = __esm({
+  "packages/core/src/terminal.ts"() {
+    init_source();
+    init_context();
+    init_utils();
+    TERMINAL_INDENT = "  ";
+    MAX_TERMINAL_NAME_LENGTH = 80;
+    MAX_TERMINAL_DEPTH = 10;
+  }
+});
 function resolveTraceDir(options = {}) {
   if (typeof options.dir === "string" && options.dir.trim() !== "") {
     return options.dir.trim();
@@ -1560,32 +1713,38 @@ function resolveTraceDir(options = {}) {
   }
   return getDefaultTraceDir();
 }
-var TraceDirectory = class {
-  #dir;
-  constructor(options = {}) {
-    this.#dir = resolveTraceDir(options);
-  }
-  getPath(filename) {
-    return filename ? path14__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 [];
+var TraceDirectory;
+var init_trace_directory = __esm({
+  "packages/core/src/trace-directory.ts"() {
+    init_utils();
+    TraceDirectory = class {
+      #dir;
+      constructor(options = {}) {
+        this.#dir = resolveTraceDir(options);
       }
-      throw e;
-    }
-  }
-  async getFileStats(filename) {
-    return await promises.stat(this.getPath(filename));
-  }
-};
-function isFiniteNumber(v) {
-  return typeof v === "number" && Number.isFinite(v);
-}
+      getPath(filename) {
+        return filename ? path14__default.default.join(this.#dir, filename) : this.#dir;
+      }
+      async list() {
+        try {
+          const files = await promises.readdir(this.#dir);
+          return files.filter((f) => f.endsWith(".jsonl"));
+        } catch (e) {
+          if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+            return [];
+          }
+          throw e;
+        }
+      }
+      async getFileStats(filename) {
+        return await promises.stat(this.getPath(filename));
+      }
+    };
+  }
+});
+function isFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
 function parseIsoToMs2(value) {
   if (value === void 0) return void 0;
   const parsed = Date.parse(value);
@@ -1816,6 +1975,11 @@ function buildRunSummary(events) {
   };
   return summary;
 }
+var init_trace_metadata = __esm({
+  "packages/core/src/trace-metadata.ts"() {
+    init_read_trace();
+  }
+});
 
 // packages/core/src/trace-filter.ts
 function toLower(s) {
@@ -1850,6 +2014,11 @@ function filterTraces(traces, options) {
   }
   return out;
 }
+var init_trace_filter = __esm({
+  "packages/core/src/trace-filter.ts"() {
+    init_duration();
+  }
+});
 
 // packages/core/src/timeline.ts
 function finite(n) {
@@ -2019,6 +2188,11 @@ function renderTimeline(timeline, options = {}) {
   }
   return lines.join("\n");
 }
+var init_timeline = __esm({
+  "packages/core/src/timeline.ts"() {
+    init_utils();
+  }
+});
 
 // packages/core/src/what.ts
 function pickCorrelation2(metadata) {
@@ -2158,6 +2332,12 @@ function renderRunWhat(summary, options = {}) {
   }
   return lines.join("\n");
 }
+var init_what = __esm({
+  "packages/core/src/what.ts"() {
+    init_trace_metadata();
+    init_utils();
+  }
+});
 
 // packages/core/src/explain.ts
 function flatten(nodes, out = []) {
@@ -2303,6 +2483,12 @@ function buildLocalExplanation(run, options = {}) {
     ]
   };
 }
+var init_explain = __esm({
+  "packages/core/src/explain.ts"() {
+    init_redactor();
+    init_redaction_profiles();
+  }
+});
 
 // packages/core/src/stats.ts
 function percentile(sorted, p) {
@@ -2442,11 +2628,11 @@ function collectCompletedSteps(events, runId) {
       if (typeof c.durationMs !== "number" || !Number.isFinite(c.durationMs)) {
         continue;
       }
-      const meta = started.get(c.stepId);
+      const meta2 = started.get(c.stepId);
       out.push({
         runId,
-        stepName: meta?.name ?? c.stepId,
-        stepType: meta?.type ?? "logic",
+        stepName: meta2?.name ?? c.stepId,
+        stepType: meta2?.type ?? "logic",
         durationMs: c.durationMs
       });
     }
@@ -2496,6 +2682,14 @@ function renderTraceStats(stats) {
   }
   return lines.join("\n");
 }
+var init_stats = __esm({
+  "packages/core/src/stats.ts"() {
+    init_trace_metadata();
+    init_trace_filter();
+    init_storage();
+    init_utils();
+  }
+});
 
 // packages/core/src/search.ts
 function parseDurationFilter(expr) {
@@ -2691,13 +2885,21 @@ async function loadTraceMetadataList(_traceDir, fileNames, getPath) {
   for (const fileName of fileNames) {
     try {
       const filePath = getPath(fileName);
-      const meta = await extractMetadata(filePath);
-      metas.push(meta);
+      const meta2 = await extractMetadata(filePath);
+      metas.push(meta2);
     } catch {
     }
   }
   return metas;
 }
+var init_search = __esm({
+  "packages/core/src/search.ts"() {
+    init_trace_metadata();
+    init_trace_filter();
+    init_storage();
+    init_duration();
+  }
+});
 
 // packages/core/src/sessions/metadata.ts
 function isNonEmptyString3(value) {
@@ -2746,19 +2948,29 @@ function extractSessionWorkflowMetadata(record) {
   }
   return found ? out : void 0;
 }
-function sessionKeyForRun(meta, options) {
-  if (meta?.sessionId) return meta.sessionId;
-  if (options?.correlateByGroupId && meta?.groupId) {
-    return `group:${meta.groupId}`;
+function sessionKeyForRun(meta2, options) {
+  if (meta2?.sessionId) return meta2.sessionId;
+  if (options?.correlateByGroupId && meta2?.groupId) {
+    return `group:${meta2.groupId}`;
   }
   return void 0;
 }
+var init_metadata = __esm({
+  "packages/core/src/sessions/metadata.ts"() {
+  }
+});
+
+// packages/core/src/sessions/types.ts
+var init_types2 = __esm({
+  "packages/core/src/sessions/types.ts"() {
+  }
+});
 
 // packages/core/src/sessions/load.ts
-async function enrichSessionRunRecord(meta) {
+async function enrichSessionRunRecord(meta2) {
   let metadata;
   try {
-    const events = await readTraceEventsFromFile(meta.filePath);
+    const events = await readTraceEventsFromFile(meta2.filePath);
     for (const event of events) {
       if (event.event !== "run_started") continue;
       if (event.metadata && typeof event.metadata === "object") {
@@ -2769,23 +2981,28 @@ async function enrichSessionRunRecord(meta) {
   } catch {
   }
   return {
-    runId: meta.runId,
-    name: meta.name,
-    status: meta.status,
-    startedAt: meta.startedAt,
-    endedAt: meta.endedAt,
-    durationMs: meta.durationMs,
-    filePath: meta.filePath,
+    runId: meta2.runId,
+    name: meta2.name,
+    status: meta2.status,
+    startedAt: meta2.startedAt,
+    endedAt: meta2.endedAt,
+    durationMs: meta2.durationMs,
+    filePath: meta2.filePath,
     metadata
   };
 }
 async function loadSessionRunRecords(metas) {
   const out = [];
-  for (const meta of metas) {
-    out.push(await enrichSessionRunRecord(meta));
+  for (const meta2 of metas) {
+    out.push(await enrichSessionRunRecord(meta2));
   }
   return out;
 }
+var init_load = __esm({
+  "packages/core/src/sessions/load.ts"() {
+    init_storage();
+  }
+});
 
 // packages/core/src/sessions/scope.ts
 function filterMetasBySessionScope(metas, records, options) {
@@ -2809,7 +3026,7 @@ function filterMetasBySessionScope(metas, records, options) {
       };
     }
     const runIdSet = new Set(session.runIds);
-    const filtered = metas.filter((meta) => runIdSet.has(meta.runId));
+    const filtered = metas.filter((meta2) => runIdSet.has(meta2.runId));
     return {
       metas: filtered,
       scopeLabel: sessionId,
@@ -2833,7 +3050,7 @@ function filterMetasBySessionScope(metas, records, options) {
     }
     const runIdSet = new Set(runIds);
     return {
-      metas: metas.filter((meta) => runIdSet.has(meta.runId)),
+      metas: metas.filter((meta2) => runIdSet.has(meta2.runId)),
       scopeLabel: groupId,
       scopeKind: "group",
       runIds,
@@ -2850,6 +3067,20 @@ function filterMetasBySessionScope(metas, records, options) {
     notFound: false
   };
 }
+var init_scope = __esm({
+  "packages/core/src/sessions/scope.ts"() {
+    init_sessions();
+    init_metadata();
+  }
+});
+
+// packages/core/src/sessions/cohort.ts
+var init_cohort = __esm({
+  "packages/core/src/sessions/cohort.ts"() {
+    init_sessions();
+    init_metadata();
+  }
+});
 
 // packages/core/src/sessions/checks.ts
 function emptySummary() {
@@ -2943,6 +3174,10 @@ function aggregateSessionCheckResults(perRun, scope) {
     ...scope.sessionWarnings?.length ? { sessionWarnings: [...scope.sessionWarnings] } : {}
   };
 }
+var init_checks = __esm({
+  "packages/core/src/sessions/checks.ts"() {
+  }
+});
 
 // packages/core/src/sessions/index.ts
 function compareRuns(a, b) {
@@ -2982,37 +3217,37 @@ function buildHandoffs(runIds, metaByRunId, warnings, sessionId) {
     edges.push(edge);
   };
   for (const runId of runIds) {
-    const meta = metaByRunId.get(runId);
-    if (!meta) continue;
-    if (meta.handoffFrom && meta.handoffTo) {
+    const meta2 = metaByRunId.get(runId);
+    if (!meta2) continue;
+    if (meta2.handoffFrom && meta2.handoffTo) {
       pushEdge({
-        from: meta.handoffFrom,
-        to: meta.handoffTo,
+        from: meta2.handoffFrom,
+        to: meta2.handoffTo,
         source: "manual",
         confidence: "explicit"
       });
       continue;
     }
-    if (meta.handoffFrom) {
+    if (meta2.handoffFrom) {
       pushEdge({
-        from: meta.handoffFrom,
+        from: meta2.handoffFrom,
         to: runId,
         source: "manual",
         confidence: "explicit"
       });
     }
-    if (meta.handoffTo) {
+    if (meta2.handoffTo) {
       pushEdge({
         from: runId,
-        to: meta.handoffTo,
+        to: meta2.handoffTo,
         source: "manual",
         confidence: "explicit"
       });
     }
-    if (meta.subAgentId && meta.parentGroupId && !meta.handoffFrom && !meta.handoffTo) {
+    if (meta2.subAgentId && meta2.parentGroupId && !meta2.handoffFrom && !meta2.handoffTo) {
       pushEdge({
-        from: meta.parentGroupId,
-        to: meta.subAgentId,
+        from: meta2.parentGroupId,
+        to: meta2.subAgentId,
         source: "inferred",
         confidence: "correlated"
       });
@@ -3033,22 +3268,22 @@ function buildHandoffs(runIds, metaByRunId, warnings, sessionId) {
 function buildRetries(runIds, metaByRunId, warnings, sessionId) {
   const retries = [];
   for (const runId of runIds) {
-    const meta = metaByRunId.get(runId);
-    if (!meta) continue;
-    if (meta.retryOf) {
+    const meta2 = metaByRunId.get(runId);
+    if (!meta2) continue;
+    if (meta2.retryOf) {
       retries.push({
         runId,
-        retryOf: meta.retryOf,
-        attempt: meta.attempt,
+        retryOf: meta2.retryOf,
+        attempt: meta2.attempt,
         source: "manual",
         confidence: "explicit"
       });
       continue;
     }
-    if (meta.attempt !== void 0 && meta.attempt > 1) {
+    if (meta2.attempt !== void 0 && meta2.attempt > 1) {
       retries.push({
         runId,
-        attempt: meta.attempt,
+        attempt: meta2.attempt,
         source: "inferred",
         confidence: "correlated"
       });
@@ -3071,12 +3306,12 @@ function buildCriticalPath(runs, handoffs) {
     handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.from)
   );
   const ordered = [...runs].sort(compareRuns);
-  const path20 = [];
+  const path22 = [];
   const visited = /* @__PURE__ */ new Set();
   const pushRun = (run, confidence, source) => {
     if (visited.has(run.runId)) return;
     visited.add(run.runId);
-    path20.push({
+    path22.push({
       runId: run.runId,
       name: run.name,
       startedAt: run.startedAt,
@@ -3101,118 +3336,1377 @@ function buildCriticalPath(runs, handoffs) {
     const confidence = explicitTargets.has(run.runId) || explicitSources.has(run.runId) ? "explicit" : "correlated";
     pushRun(run, confidence, confidence === "explicit" ? "manual" : "inferred");
   }
-  return path20;
+  return path22;
+}
+function metaRunIdMatches(run, token, runById) {
+  const meta2 = extractSessionWorkflowMetadata(run.metadata);
+  return meta2?.subAgentId === token || meta2?.groupId === token || runById.has(token);
+}
+function buildSessionIndex(inputRuns, options = {}) {
+  const warnings = [];
+  const runs = [...inputRuns].sort(compareRuns);
+  const metaByRunId = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    metaByRunId.set(run.runId, extractSessionWorkflowMetadata(run.metadata));
+  }
+  const sessionsByKey = /* @__PURE__ */ new Map();
+  const unscopedRunIds = [];
+  for (const run of runs) {
+    const meta2 = metaByRunId.get(run.runId);
+    const key = sessionKeyForRun(meta2, {
+      correlateByGroupId: options.correlateByGroupId === true
+    });
+    if (!key) {
+      unscopedRunIds.push(run.runId);
+      continue;
+    }
+    const bucket = sessionsByKey.get(key) ?? [];
+    bucket.push(run);
+    sessionsByKey.set(key, bucket);
+  }
+  const sessions = [...sessionsByKey.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([sessionId, sessionRuns]) => {
+    const runIds = sessionRuns.map((run) => run.runId).sort();
+    const handoffs = buildHandoffs(runIds, metaByRunId, warnings, sessionId);
+    const retries = buildRetries(runIds, metaByRunId, warnings, sessionId);
+    const groups = buildGroups(runIds, metaByRunId);
+    const criticalPath = buildCriticalPath(sessionRuns, handoffs);
+    const confidences = new Set(handoffs.map((edge) => edge.confidence));
+    if (confidences.has("explicit") && confidences.has("correlated")) {
+      warnings.push({
+        code: "mixed-confidence-group",
+        message: "Session aggregates explicit and correlated handoff edges.",
+        sessionId
+      });
+    }
+    return {
+      sessionId,
+      runIds,
+      groups,
+      handoffs,
+      retries,
+      criticalPath
+    };
+  });
+  if (sessions.length === 0 && runs.length > 0) {
+    warnings.push({
+      code: "missing-session-id",
+      message: "No sessionId (or correlated groupId) found on input runs."
+    });
+  }
+  warnings.sort((a, b) => {
+    const code = a.code.localeCompare(b.code);
+    if (code !== 0) return code;
+    return (a.runId ?? "").localeCompare(b.runId ?? "");
+  });
+  return {
+    runs,
+    sessions,
+    unscopedRunIds: unscopedRunIds.sort(),
+    warnings
+  };
+}
+var init_sessions = __esm({
+  "packages/core/src/sessions/index.ts"() {
+    init_metadata();
+    init_metadata();
+    init_types2();
+    init_load();
+    init_scope();
+    init_cohort();
+    init_checks();
+  }
+});
+function isRecord6(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 (!isRecord6(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;
+  }
+}
+var KNOWN_EVENTS;
+var init_trace_verification = __esm({
+  "packages/core/src/trace-verification.ts"() {
+    init_types();
+    KNOWN_EVENTS = /* @__PURE__ */ new Set([
+      "run_started",
+      "run_completed",
+      "step_started",
+      "step_completed"
+    ]);
+  }
+});
+
+// packages/core/src/inspect-run.ts
+var init_inspect_run = __esm({
+  "packages/core/src/inspect-run.ts"() {
+    init_correlation_metadata();
+    init_context();
+    init_storage();
+    init_terminal();
+    init_trace_directory();
+    init_trace_event_safety();
+    init_utils();
+  }
+});
+
+// packages/core/src/maybe-inspect-run.ts
+var init_maybe_inspect_run = __esm({
+  "packages/core/src/maybe-inspect-run.ts"() {
+    init_inspect_run();
+  }
+});
+
+// packages/core/src/entries/advanced.ts
+var init_advanced = __esm({
+  "packages/core/src/entries/advanced.ts"() {
+    init_context();
+    init_inspector();
+    init_inspector_runtime();
+    init_trace_event_safety();
+    init_terminal();
+    init_utils();
+    init_types();
+    init_storage();
+    init_read_trace();
+    init_trace_directory();
+    init_trace_metadata();
+    init_trace_filter();
+    init_timeline();
+    init_what();
+    init_explain();
+    init_stats();
+    init_search();
+    init_sessions();
+    init_trace_verification();
+    init_duration();
+    init_maybe_inspect_run();
+  }
+});
+
+// packages/index-sqlite/src/types.ts
+var INDEX_SCHEMA_VERSION, INDEX_DB_FILENAME;
+var init_types3 = __esm({
+  "packages/index-sqlite/src/types.ts"() {
+    INDEX_SCHEMA_VERSION = "1";
+    INDEX_DB_FILENAME = "trace-index.sqlite";
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/util.js
+var require_util = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/util.js"(exports$1) {
+    exports$1.getBooleanOption = (options, key) => {
+      let value = false;
+      if (key in options && typeof (value = options[key]) !== "boolean") {
+        throw new TypeError(`Expected the "${key}" option to be a boolean`);
+      }
+      return value;
+    };
+    exports$1.cppdb = /* @__PURE__ */ Symbol();
+    exports$1.inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/sqlite-error.js"(exports$1, module) {
+    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+    function SqliteError(message, code) {
+      if (new.target !== SqliteError) {
+        return new SqliteError(message, code);
+      }
+      if (typeof code !== "string") {
+        throw new TypeError("Expected second argument to be a string");
+      }
+      Error.call(this, message);
+      descriptor.value = "" + message;
+      Object.defineProperty(this, "message", descriptor);
+      Error.captureStackTrace(this, SqliteError);
+      this.code = code;
+    }
+    Object.setPrototypeOf(SqliteError, Error);
+    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+    Object.defineProperty(SqliteError.prototype, "name", descriptor);
+    module.exports = SqliteError;
+  }
+});
+
+// node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS({
+  "node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js"(exports$1, module) {
+    var sep = __require("path").sep || "/";
+    module.exports = fileUriToPath;
+    function fileUriToPath(uri) {
+      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
+        throw new TypeError("must pass in a file:// URI to convert to a file path");
+      }
+      var rest = decodeURI(uri.substring(7));
+      var firstSlash = rest.indexOf("/");
+      var host = rest.substring(0, firstSlash);
+      var path22 = rest.substring(firstSlash + 1);
+      if ("localhost" == host) host = "";
+      if (host) {
+        host = sep + sep + host;
+      }
+      path22 = path22.replace(/^(.+)\|/, "$1:");
+      if (sep == "\\") {
+        path22 = path22.replace(/\//g, "\\");
+      }
+      if (/^.+\:/.test(path22)) ; else {
+        path22 = sep + path22;
+      }
+      return host + path22;
+    }
+  }
+});
+
+// node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js
+var require_bindings = __commonJS({
+  "node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js"(exports$1, module) {
+    var fs = __require("fs");
+    var path22 = __require("path");
+    var fileURLToPath2 = require_file_uri_to_path();
+    var join = path22.join;
+    var dirname = path22.dirname;
+    var exists = fs.accessSync && function(path23) {
+      try {
+        fs.accessSync(path23);
+      } catch (e) {
+        return false;
+      }
+      return true;
+    } || fs.existsSync || path22.existsSync;
+    var defaults = {
+      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
+      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+      platform: process.platform,
+      arch: process.arch,
+      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+      version: process.versions.node,
+      bindings: "bindings.node",
+      try: [
+        // node-gyp's linked version in the "build" dir
+        ["module_root", "build", "bindings"],
+        // node-waf and gyp_addon (a.k.a node-gyp)
+        ["module_root", "build", "Debug", "bindings"],
+        ["module_root", "build", "Release", "bindings"],
+        // Debug files, for development (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Debug", "bindings"],
+        ["module_root", "Debug", "bindings"],
+        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Release", "bindings"],
+        ["module_root", "Release", "bindings"],
+        // Legacy from node-waf, node <= 0.4.x
+        ["module_root", "build", "default", "bindings"],
+        // Production "Release" buildtype binary (meh...)
+        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+        // node-qbs builds
+        ["module_root", "addon-build", "release", "install-root", "bindings"],
+        ["module_root", "addon-build", "debug", "install-root", "bindings"],
+        ["module_root", "addon-build", "default", "install-root", "bindings"],
+        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
+      ]
+    };
+    function bindings(opts) {
+      if (typeof opts == "string") {
+        opts = { bindings: opts };
+      } else if (!opts) {
+        opts = {};
+      }
+      Object.keys(defaults).map(function(i2) {
+        if (!(i2 in opts)) opts[i2] = defaults[i2];
+      });
+      if (!opts.module_root) {
+        opts.module_root = exports$1.getRoot(exports$1.getFileName());
+      }
+      if (path22.extname(opts.bindings) != ".node") {
+        opts.bindings += ".node";
+      }
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+      var tries = [], i = 0, l = opts.try.length, n, b, err;
+      for (; i < l; i++) {
+        n = join.apply(
+          null,
+          opts.try[i].map(function(p) {
+            return opts[p] || p;
+          })
+        );
+        tries.push(n);
+        try {
+          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+          if (!opts.path) {
+            b.path = n;
+          }
+          return b;
+        } catch (e) {
+          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
+            throw e;
+          }
+        }
+      }
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
+          return opts.arrow + a;
+        }).join("\n")
+      );
+      err.tries = tries;
+      throw err;
+    }
+    module.exports = exports$1 = bindings;
+    exports$1.getFileName = function getFileName(calling_file) {
+      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+      Error.stackTraceLimit = 10;
+      Error.prepareStackTrace = function(e, st) {
+        for (var i = 0, l = st.length; i < l; i++) {
+          fileName = st[i].getFileName();
+          if (fileName !== __filename) {
+            if (calling_file) {
+              if (fileName !== calling_file) {
+                return;
+              }
+            } else {
+              return;
+            }
+          }
+        }
+      };
+      Error.captureStackTrace(dummy);
+      dummy.stack;
+      Error.prepareStackTrace = origPST;
+      Error.stackTraceLimit = origSTL;
+      var fileSchema = "file://";
+      if (fileName.indexOf(fileSchema) === 0) {
+        fileName = fileURLToPath2(fileName);
+      }
+      return fileName;
+    };
+    exports$1.getRoot = function getRoot(file) {
+      var dir = dirname(file), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
+        }
+        if (exists(join(dir, "package.json")) || exists(join(dir, "node_modules"))) {
+          return dir;
+        }
+        if (prev === dir) {
+          throw new Error(
+            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
+          );
+        }
+        prev = dir;
+        dir = join(dir, "..");
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/wrappers.js"(exports$1) {
+    var { cppdb } = require_util();
+    exports$1.prepare = function prepare(sql) {
+      return this[cppdb].prepare(sql, this, false);
+    };
+    exports$1.exec = function exec(sql) {
+      this[cppdb].exec(sql);
+      return this;
+    };
+    exports$1.close = function close() {
+      this[cppdb].close();
+      return this;
+    };
+    exports$1.loadExtension = function loadExtension(...args) {
+      this[cppdb].loadExtension(...args);
+      return this;
+    };
+    exports$1.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+      this[cppdb].defaultSafeIntegers(...args);
+      return this;
+    };
+    exports$1.unsafeMode = function unsafeMode(...args) {
+      this[cppdb].unsafeMode(...args);
+      return this;
+    };
+    exports$1.getters = {
+      name: {
+        get: function name() {
+          return this[cppdb].name;
+        },
+        enumerable: true
+      },
+      open: {
+        get: function open3() {
+          return this[cppdb].open;
+        },
+        enumerable: true
+      },
+      inTransaction: {
+        get: function inTransaction() {
+          return this[cppdb].inTransaction;
+        },
+        enumerable: true
+      },
+      readonly: {
+        get: function readonly() {
+          return this[cppdb].readonly;
+        },
+        enumerable: true
+      },
+      memory: {
+        get: function memory() {
+          return this[cppdb].memory;
+        },
+        enumerable: true
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/transaction.js"(exports$1, module) {
+    var { cppdb } = require_util();
+    var controllers = /* @__PURE__ */ new WeakMap();
+    module.exports = function transaction(fn) {
+      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
+      const db = this[cppdb];
+      const controller = getController(db, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
+    };
+    var getController = (db, self) => {
+      let controller = controllers.get(db);
+      if (!controller) {
+        const shared = {
+          commit: db.prepare("COMMIT", self, false),
+          rollback: db.prepare("ROLLBACK", self, false),
+          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db, controller = {
+          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
+      }
+      return controller;
+    };
+    var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
+      } else {
+        before = begin;
+        after = commit;
+        undo = rollback;
+      }
+      before.run();
+      try {
+        const result = apply.call(fn, this, arguments);
+        if (result && typeof result.then === "function") {
+          throw new TypeError("Transaction function cannot return a promise");
+        }
+        after.run();
+        return result;
+      } catch (ex) {
+        if (db.inTransaction) {
+          undo.run();
+          if (undo !== rollback) after.run();
+        }
+        throw ex;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/pragma.js"(exports$1, module) {
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function pragma(source, options) {
+      if (options == null) options = {};
+      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      const simple = getBooleanOption(options, "simple");
+      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/backup.js"(exports$1, module) {
+    var fs = __require("fs");
+    var path22 = __require("path");
+    var { promisify } = __require("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify(fs.access);
+    module.exports = async function backup(filename, options) {
+      if (options == null) options = {};
+      if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      filename = filename.trim();
+      const attachedName = "attached" in options ? options.attached : "main";
+      const handler = "progress" in options ? options.progress : null;
+      if (!filename) throw new TypeError("Backup filename cannot be an empty string");
+      if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
+      await fsAccess(path22.dirname(filename)).catch(() => {
+        throw new TypeError("Cannot save backup because the directory does not exist");
+      });
+      const isNewFile = await fsAccess(filename).then(() => false, () => true);
+      return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
+    };
+    var runBackup = (backup, handler) => {
+      let rate = 0;
+      let useDefault = true;
+      return new Promise((resolve, reject) => {
+        setImmediate(function step() {
+          try {
+            const progress = backup.transfer(rate);
+            if (!progress.remainingPages) {
+              backup.close();
+              resolve(progress);
+              return;
+            }
+            if (useDefault) {
+              useDefault = false;
+              rate = 100;
+            }
+            if (handler) {
+              const ret = handler(progress);
+              if (ret !== void 0) {
+                if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+                else throw new TypeError("Expected progress callback to return a number or undefined");
+              }
+            }
+            setImmediate(step);
+          } catch (err) {
+            backup.close();
+            reject(err);
+          }
+        });
+      });
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/serialize.js"(exports$1, module) {
+    var { cppdb } = require_util();
+    module.exports = function serialize(options) {
+      if (options == null) options = {};
+      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
+      const attachedName = "attached" in options ? options.attached : "main";
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      return this[cppdb].serialize(attachedName);
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/function.js"(exports$1, module) {
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineFunction(name, options, fn) {
+      if (options == null) options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = fn.length;
+        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/aggregate.js"(exports$1, module) {
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineAggregate(name, options) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const start = "start" in options ? options.start : null;
+      const step = getFunctionOption(options, "step", true);
+      const inverse = getFunctionOption(options, "inverse", false);
+      const result = getFunctionOption(options, "result", false);
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+        if (argCount > 0) argCount -= 1;
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+    var getFunctionOption = (options, key, required) => {
+      const value = key in options ? options[key] : null;
+      if (typeof value === "function") return value;
+      if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
+      if (required) throw new TypeError(`Missing required option "${key}"`);
+      return null;
+    };
+    var getLength = ({ length }) => {
+      if (Number.isInteger(length) && length >= 0) return length;
+      throw new TypeError("Expected function.length to be a positive integer");
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/table.js"(exports$1, module) {
+    var { cppdb } = require_util();
+    module.exports = function defineTable(name, factory) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
+      let eponymous = false;
+      if (typeof factory === "object" && factory !== null) {
+        eponymous = true;
+        factory = defer(parseTableDefinition(factory, "used", name));
+      } else {
+        if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
+        factory = wrapFactory(factory);
+      }
+      this[cppdb].table(factory, name, eponymous);
+      return this;
+    };
+    function wrapFactory(factory) {
+      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+        const thisObject = {
+          module: moduleName,
+          database: databaseName,
+          table: tableName
+        };
+        const def = apply.call(factory, thisObject, args);
+        if (typeof def !== "object" || def === null) {
+          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+        }
+        return parseTableDefinition(def, "returned", moduleName);
+      };
+    }
+    function parseTableDefinition(def, verb, moduleName) {
+      if (!hasOwnProperty.call(def, "rows")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+      }
+      if (!hasOwnProperty.call(def, "columns")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+      }
+      const rows = def.rows;
+      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+      }
+      let columns = def.columns;
+      if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+      }
+      if (columns.length !== new Set(columns).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+      }
+      if (!columns.length) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+      }
+      let parameters;
+      if (hasOwnProperty.call(def, "parameters")) {
+        parameters = def.parameters;
+        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+        }
+      } else {
+        parameters = inferParameters(rows);
+      }
+      if (parameters.length !== new Set(parameters).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+      }
+      if (parameters.length > 32) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+      }
+      for (const parameter of parameters) {
+        if (columns.includes(parameter)) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+        }
+      }
+      let safeIntegers = 2;
+      if (hasOwnProperty.call(def, "safeIntegers")) {
+        const bool = def.safeIntegers;
+        if (typeof bool !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+        }
+        safeIntegers = +bool;
+      }
+      let directOnly = false;
+      if (hasOwnProperty.call(def, "directOnly")) {
+        directOnly = def.directOnly;
+        if (typeof directOnly !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+        }
+      }
+      const columnDefinitions = [
+        ...parameters.map(identifier).map((str2) => `${str2} HIDDEN`),
+        ...columns.map(identifier)
+      ];
+      return [
+        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
+        wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+        parameters,
+        safeIntegers,
+        directOnly
+      ];
+    }
+    function wrapGenerator(generator, columnMap, moduleName) {
+      return function* virtualTable(...args) {
+        const output2 = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+        for (let i = 0; i < columnMap.size; ++i) {
+          output2.push(null);
+        }
+        for (const row of generator(...args)) {
+          if (Array.isArray(row)) {
+            extractRowArray(row, output2, columnMap.size, moduleName);
+            yield output2;
+          } else if (typeof row === "object" && row !== null) {
+            extractRowObject(row, output2, columnMap, moduleName);
+            yield output2;
+          } else {
+            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+          }
+        }
+      };
+    }
+    function extractRowArray(row, output2, columnCount, moduleName) {
+      if (row.length !== columnCount) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+      }
+      const offset = output2.length - columnCount;
+      for (let i = 0; i < columnCount; ++i) {
+        output2[i + offset] = row[i];
+      }
+    }
+    function extractRowObject(row, output2, columnMap, moduleName) {
+      let count = 0;
+      for (const key of Object.keys(row)) {
+        const index = columnMap.get(key);
+        if (index === void 0) {
+          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+        }
+        output2[index] = row[key];
+        count += 1;
+      }
+      if (count !== columnMap.size) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+      }
+    }
+    function inferParameters({ length }) {
+      if (!Number.isInteger(length) || length < 0) {
+        throw new TypeError("Expected function.length to be a positive integer");
+      }
+      const params = [];
+      for (let i = 0; i < length; ++i) {
+        params.push(`$${i + 1}`);
+      }
+      return params;
+    }
+    var { hasOwnProperty } = Object.prototype;
+    var { apply } = Function.prototype;
+    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
+    });
+    var identifier = (str2) => `"${str2.replace(/"/g, '""')}"`;
+    var defer = (x) => () => x;
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/inspect.js"(exports$1, module) {
+    var DatabaseInspection = function Database3() {
+    };
+    module.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
+    };
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/database.js"(exports$1, module) {
+    var fs = __require("fs");
+    var path22 = __require("path");
+    var util = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database3(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database3(filenameGiven, options);
+      }
+      let buffer;
+      if (Buffer.isBuffer(filenameGiven)) {
+        buffer = filenameGiven;
+        filenameGiven = ":memory:";
+      }
+      if (filenameGiven == null) filenameGiven = "";
+      if (options == null) options = {};
+      if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+      if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+      const filename = filenameGiven.trim();
+      const anonymous = filename === "" || filename === ":memory:";
+      const readonly = util.getBooleanOption(options, "readonly");
+      const fileMustExist = util.getBooleanOption(options, "fileMustExist");
+      const timeout = "timeout" in options ? options.timeout : 5e3;
+      const verbose = "verbose" in options ? options.verbose : null;
+      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+      if (readonly && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
+      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
+      if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+      if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
+      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+      let addon;
+      if (nativeBinding == null) {
+        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+      } else if (typeof nativeBinding === "string") {
+        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require;
+        addon = requireFunc(path22.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+      } else {
+        addon = nativeBinding;
+      }
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
+      }
+      if (!anonymous && !fs.existsSync(path22.dirname(filename))) {
+        throw new TypeError("Cannot open database because the directory does not exist");
+      }
+      Object.defineProperties(this, {
+        [util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
+        ...wrappers.getters
+      });
+    }
+    var wrappers = require_wrappers();
+    Database3.prototype.prepare = wrappers.prepare;
+    Database3.prototype.transaction = require_transaction();
+    Database3.prototype.pragma = require_pragma();
+    Database3.prototype.backup = require_backup();
+    Database3.prototype.serialize = require_serialize();
+    Database3.prototype.function = require_function();
+    Database3.prototype.aggregate = require_aggregate();
+    Database3.prototype.table = require_table();
+    Database3.prototype.loadExtension = wrappers.loadExtension;
+    Database3.prototype.exec = wrappers.exec;
+    Database3.prototype.close = wrappers.close;
+    Database3.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database3.prototype.unsafeMode = wrappers.unsafeMode;
+    Database3.prototype[util.inspect] = require_inspect();
+    module.exports = Database3;
+  }
+});
+
+// node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/index.js"(exports$1, module) {
+    module.exports = require_database();
+    module.exports.SqliteError = require_sqlite_error();
+  }
+});
+
+// packages/index-sqlite/src/schema.ts
+function metaDefaults(sourceDir, fileCount) {
+  return {
+    [META_KEYS.schemaVersion]: INDEX_SCHEMA_VERSION,
+    [META_KEYS.builtAt]: (/* @__PURE__ */ new Date()).toISOString(),
+    [META_KEYS.sourceDir]: sourceDir,
+    [META_KEYS.fileCount]: String(fileCount),
+    [META_KEYS.driver]: "better-sqlite3"
+  };
+}
+var INDEX_SCHEMA_SQL, DERIVE_SESSIONS_SQL, META_KEYS;
+var init_schema = __esm({
+  "packages/index-sqlite/src/schema.ts"() {
+    init_types3();
+    INDEX_SCHEMA_SQL = `
+DROP TABLE IF EXISTS meta;
+DROP TABLE IF EXISTS errors;
+DROP TABLE IF EXISTS steps;
+DROP TABLE IF EXISTS sessions;
+DROP TABLE IF EXISTS runs;
+
+CREATE TABLE meta (
+  key TEXT PRIMARY KEY,
+  value TEXT
+);
+
+CREATE TABLE runs (
+  run_id TEXT PRIMARY KEY,
+  file TEXT NOT NULL,
+  mtime_ms REAL NOT NULL,
+  name TEXT,
+  status TEXT,
+  started_at REAL,
+  ended_at REAL,
+  duration_ms REAL,
+  session_id TEXT,
+  group_id TEXT,
+  correlation_id TEXT
+);
+
+CREATE TABLE steps (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id TEXT NOT NULL,
+  step_id TEXT NOT NULL,
+  kind TEXT,
+  name TEXT,
+  status TEXT,
+  duration_ms REAL,
+  tool_name TEXT,
+  model TEXT,
+  parent_id TEXT
+);
+
+CREATE TABLE errors (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id TEXT NOT NULL,
+  step_id TEXT,
+  message TEXT,
+  code TEXT
+);
+
+CREATE TABLE sessions (
+  session_id TEXT PRIMARY KEY,
+  run_count INTEGER NOT NULL,
+  first_started_at REAL,
+  last_ended_at REAL
+);
+
+CREATE INDEX idx_runs_status ON runs(status);
+CREATE INDEX idx_runs_session ON runs(session_id);
+CREATE INDEX idx_runs_started ON runs(started_at);
+CREATE INDEX idx_steps_run ON steps(run_id);
+CREATE INDEX idx_steps_kind ON steps(kind);
+CREATE INDEX idx_steps_tool ON steps(tool_name);
+`;
+    DERIVE_SESSIONS_SQL = `
+INSERT INTO sessions (session_id, run_count, first_started_at, last_ended_at)
+SELECT session_id, COUNT(*), MIN(started_at), MAX(ended_at)
+FROM runs
+WHERE session_id IS NOT NULL
+GROUP BY session_id;
+`;
+    META_KEYS = {
+      schemaVersion: "schemaVersion",
+      builtAt: "builtAt",
+      sourceDir: "sourceDir",
+      fileCount: "fileCount",
+      driver: "driver"
+    };
+  }
+});
+function resolveIndexDbPath(traceDir, dbPath) {
+  if (dbPath && dbPath.trim() !== "") return path14__default.default.resolve(dbPath);
+  return path14__default.default.join(path14__default.default.resolve(traceDir), INDEX_DB_FILENAME);
 }
-function metaRunIdMatches(run, token, runById) {
-  const meta = extractSessionWorkflowMetadata(run.metadata);
-  return meta?.subAgentId === token || meta?.groupId === token || runById.has(token);
+function str(value) {
+  return typeof value === "string" && value !== "" ? value : null;
 }
-function buildSessionIndex(inputRuns, options = {}) {
-  const warnings = [];
-  const runs = [...inputRuns].sort(compareRuns);
-  const metaByRunId = /* @__PURE__ */ new Map();
-  for (const run of runs) {
-    metaByRunId.set(run.runId, extractSessionWorkflowMetadata(run.metadata));
-  }
-  const sessionsByKey = /* @__PURE__ */ new Map();
-  const unscopedRunIds = [];
-  for (const run of runs) {
-    const meta = metaByRunId.get(run.runId);
-    const key = sessionKeyForRun(meta, {
-      correlateByGroupId: options.correlateByGroupId === true
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function deriveRun(file, mtimeMs, events) {
+  const started = events.find((e) => e.event === "run_started");
+  if (!started || started.event !== "run_started") return null;
+  const completed = events.find((e) => e.event === "run_completed");
+  const metadata = started.metadata ?? {};
+  const run = {
+    runId: started.runId,
+    file,
+    mtimeMs,
+    name: str(started.name),
+    status: completed && completed.event === "run_completed" ? completed.status : null,
+    startedAt: num(started.startTime),
+    endedAt: completed && completed.event === "run_completed" ? num(completed.endTime) : null,
+    durationMs: completed && completed.event === "run_completed" ? num(completed.durationMs) : null,
+    sessionId: str(metadata.sessionId),
+    groupId: str(metadata.groupId),
+    correlationId: str(metadata.correlationId)
+  };
+  const stepStarts = /* @__PURE__ */ new Map();
+  const steps = [];
+  const errors = [];
+  if (completed && completed.event === "run_completed" && completed.error) {
+    errors.push({
+      stepId: null,
+      message: str(completed.error.message),
+      code: str(completed.error.code)
     });
-    if (!key) {
-      unscopedRunIds.push(run.runId);
-      continue;
+  }
+  for (const event of events) {
+    if (event.event === "step_started") {
+      stepStarts.set(event.stepId, event);
     }
-    const bucket = sessionsByKey.get(key) ?? [];
-    bucket.push(run);
-    sessionsByKey.set(key, bucket);
   }
-  const sessions = [...sessionsByKey.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([sessionId, sessionRuns]) => {
-    const runIds = sessionRuns.map((run) => run.runId).sort();
-    const handoffs = buildHandoffs(runIds, metaByRunId, warnings, sessionId);
-    const retries = buildRetries(runIds, metaByRunId, warnings, sessionId);
-    const groups = buildGroups(runIds, metaByRunId);
-    const criticalPath = buildCriticalPath(sessionRuns, handoffs);
-    const confidences = new Set(handoffs.map((edge) => edge.confidence));
-    if (confidences.has("explicit") && confidences.has("correlated")) {
-      warnings.push({
-        code: "mixed-confidence-group",
-        message: "Session aggregates explicit and correlated handoff edges.",
-        sessionId
+  for (const event of events) {
+    if (event.event !== "step_completed") continue;
+    const start = stepStarts.get(event.stepId);
+    const meta2 = start?.metadata ?? {};
+    steps.push({
+      runId: run.runId,
+      stepId: event.stepId,
+      kind: start ? str(start.type) : null,
+      name: start ? str(start.name) : null,
+      status: event.status,
+      durationMs: num(event.durationMs),
+      toolName: str(meta2.toolName),
+      model: str(meta2.model),
+      parentId: start ? str(start.parentId) : null
+    });
+    if (event.error) {
+      errors.push({
+        stepId: event.stepId,
+        message: str(event.error.message),
+        code: str(event.error.code)
       });
     }
-    return {
-      sessionId,
-      runIds,
-      groups,
-      handoffs,
-      retries,
-      criticalPath
-    };
-  });
-  if (sessions.length === 0 && runs.length > 0) {
-    warnings.push({
-      code: "missing-session-id",
-      message: "No sessionId (or correlated groupId) found on input runs."
+  }
+  return { run, steps, errors };
+}
+async function buildIndex(options = {}) {
+  const traceDir = resolveTraceDir({ dir: options.traceDir });
+  const dbPath = resolveIndexDbPath(traceDir, options.dbPath);
+  const maxRuns = options.maxRuns ?? DEFAULT_MAX_RUNS;
+  const warnings = [];
+  const td = new TraceDirectory({ dir: traceDir });
+  const files = await td.list();
+  if (files.length > maxRuns) {
+    warnings.push(
+      `index.truncated: ${files.length} trace files present; indexing first ${maxRuns}`
+    );
+  }
+  const slice = files.slice(0, maxRuns);
+  const derived = [];
+  for (const file of slice) {
+    try {
+      const raw = await promises.readFile(td.getPath(file), "utf-8");
+      const parsed = parseTraceJsonl(raw, { validate: validateEvent });
+      const stats = await td.getFileStats(file);
+      const one = deriveRun(file, stats.mtimeMs, parsed.events);
+      if (one) derived.push(one);
+      else warnings.push(`index.skipped: ${file} has no run_started event`);
+    } catch {
+      warnings.push(`index.unreadable: ${file}`);
+    }
+  }
+  await promises.mkdir(path14__default.default.dirname(dbPath), { recursive: true });
+  await promises.rm(dbPath, { force: true });
+  const db = new import_better_sqlite3.default(dbPath);
+  let runCount = 0;
+  let stepCount = 0;
+  let errorCount = 0;
+  try {
+    db.pragma("journal_mode = WAL");
+    db.exec(INDEX_SCHEMA_SQL);
+    const insertRun = db.prepare(
+      `INSERT INTO runs (run_id, file, mtime_ms, name, status, started_at, ended_at, duration_ms, session_id, group_id, correlation_id)
+       VALUES (@runId, @file, @mtimeMs, @name, @status, @startedAt, @endedAt, @durationMs, @sessionId, @groupId, @correlationId)`
+    );
+    const insertStep = db.prepare(
+      `INSERT INTO steps (run_id, step_id, kind, name, status, duration_ms, tool_name, model, parent_id)
+       VALUES (@runId, @stepId, @kind, @name, @status, @durationMs, @toolName, @model, @parentId)`
+    );
+    const insertError = db.prepare(
+      `INSERT INTO errors (run_id, step_id, message, code) VALUES (@runId, @stepId, @message, @code)`
+    );
+    const insertMeta = db.prepare(`INSERT INTO meta (key, value) VALUES (?, ?)`);
+    const write = db.transaction((items) => {
+      const seen = /* @__PURE__ */ new Set();
+      for (const item of items) {
+        if (seen.has(item.run.runId)) continue;
+        seen.add(item.run.runId);
+        insertRun.run(item.run);
+        runCount += 1;
+        for (const step of item.steps) {
+          insertStep.run(step);
+          stepCount += 1;
+        }
+        for (const err of item.errors) {
+          insertError.run({ runId: item.run.runId, ...err });
+          errorCount += 1;
+        }
+      }
+      db.exec(DERIVE_SESSIONS_SQL);
+      for (const [key, value] of Object.entries(metaDefaults(traceDir, slice.length))) {
+        insertMeta.run(key, value);
+      }
     });
+    write(derived);
+  } finally {
+    db.close();
   }
-  warnings.sort((a, b) => {
-    const code = a.code.localeCompare(b.code);
-    if (code !== 0) return code;
-    return (a.runId ?? "").localeCompare(b.runId ?? "");
-  });
+  const builtAtRow = readMetaValue(dbPath, META_KEYS.builtAt);
   return {
-    runs,
-    sessions,
-    unscopedRunIds: unscopedRunIds.sort(),
+    dbPath,
+    traceDir,
+    runs: runCount,
+    steps: stepCount,
+    errors: errorCount,
+    builtAt: builtAtRow ?? (/* @__PURE__ */ new Date()).toISOString(),
     warnings
   };
 }
-var KNOWN_EVENTS = /* @__PURE__ */ new Set([
-  "run_started",
-  "run_completed",
-  "step_started",
-  "step_completed"
-]);
-function isRecord6(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function safeParse(line) {
+function readMetaValue(dbPath, key) {
   try {
-    return JSON.parse(line);
+    const db = new import_better_sqlite3.default(dbPath, { readonly: true, fileMustExist: true });
+    try {
+      const row = db.prepare(`SELECT value FROM meta WHERE key = ?`).get(key);
+      return row?.value ?? null;
+    } finally {
+      db.close();
+    }
   } catch {
-    return void 0;
+    return null;
   }
 }
-async function isAgentInspectTrace(filePath) {
+async function cleanIndex(dbPath) {
+  await promises.rm(dbPath, { force: true });
+  await promises.rm(`${dbPath}-wal`, { force: true });
+  await promises.rm(`${dbPath}-shm`, { force: true });
+}
+var import_better_sqlite3, DEFAULT_MAX_RUNS, rebuildIndex;
+var init_builder = __esm({
+  "packages/index-sqlite/src/builder.ts"() {
+    import_better_sqlite3 = __toESM(require_lib());
+    init_advanced();
+    init_schema();
+    init_types3();
+    DEFAULT_MAX_RUNS = 1e4;
+    rebuildIndex = buildIndex;
+  }
+});
+function openHealthy(dbPath) {
+  if (!fs.existsSync(dbPath)) return null;
   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 (!isRecord6(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;
+    const db = new import_better_sqlite32.default(dbPath, { readonly: true, fileMustExist: true });
+    try {
+      const result = db.pragma("integrity_check", { simple: true });
+      if (result !== "ok") {
+        db.close();
+        return null;
       }
-      if (checked >= 20) break;
+      db.prepare(`SELECT 1 FROM meta LIMIT 1`).get();
+      db.prepare(`SELECT 1 FROM runs LIMIT 1`).get();
+      return { db, healthy: true };
+    } catch {
+      db.close();
+      return null;
     }
-    return false;
   } catch {
-    return false;
+    return null;
+  }
+}
+function meta(db, key) {
+  const row = db.prepare(`SELECT value FROM meta WHERE key = ?`).get(key);
+  return row?.value ?? null;
+}
+function indexStatus(dbPath) {
+  const opened = openHealthy(dbPath);
+  if (!opened) {
+    return {
+      dbPath,
+      exists: fs.existsSync(dbPath),
+      healthy: false,
+      builtAt: null,
+      sourceDir: null,
+      schemaVersion: null,
+      runs: 0,
+      steps: 0
+    };
+  }
+  const { db } = opened;
+  try {
+    const runs = db.prepare(`SELECT COUNT(*) AS c FROM runs`).get().c;
+    const steps = db.prepare(`SELECT COUNT(*) AS c FROM steps`).get().c;
+    return {
+      dbPath,
+      exists: true,
+      healthy: true,
+      builtAt: meta(db, META_KEYS.builtAt),
+      sourceDir: meta(db, META_KEYS.sourceDir),
+      schemaVersion: meta(db, META_KEYS.schemaVersion),
+      runs,
+      steps
+    };
+  } finally {
+    db.close();
+  }
+}
+function isIndexStale(dbPath, newestTraceMtimeMs2) {
+  const opened = openHealthy(dbPath);
+  if (!opened) return true;
+  try {
+    const builtAt = meta(opened.db, META_KEYS.builtAt);
+    if (!builtAt) return true;
+    const builtMs = Date.parse(builtAt);
+    if (Number.isNaN(builtMs)) return true;
+    return newestTraceMtimeMs2 > builtMs;
+  } finally {
+    opened.db.close();
+  }
+}
+function mapRow(row) {
+  return {
+    runId: row.run_id,
+    file: row.file,
+    mtimeMs: row.mtime_ms,
+    name: row.name ?? null,
+    status: row.status ?? null,
+    startedAt: row.started_at ?? null,
+    endedAt: row.ended_at ?? null,
+    durationMs: row.duration_ms ?? null,
+    sessionId: row.session_id ?? null,
+    groupId: row.group_id ?? null,
+    correlationId: row.correlation_id ?? null
+  };
+}
+function queryRuns(dbPath, query = {}) {
+  const opened = openHealthy(dbPath);
+  if (!opened) return [];
+  const { db } = opened;
+  try {
+    const where = [];
+    const params = {};
+    if (query.status) {
+      where.push(`r.status = @status`);
+      params.status = query.status;
+    }
+    if (query.sessionId) {
+      where.push(`r.session_id = @sessionId`);
+      params.sessionId = query.sessionId;
+    }
+    if (query.name) {
+      where.push(`LOWER(r.name) LIKE @name`);
+      params.name = `%${query.name.toLowerCase()}%`;
+    }
+    if (query.kind) {
+      where.push(`EXISTS (SELECT 1 FROM steps s WHERE s.run_id = r.run_id AND s.kind = @kind)`);
+      params.kind = query.kind;
+    }
+    if (query.tool) {
+      where.push(
+        `EXISTS (SELECT 1 FROM steps s WHERE s.run_id = r.run_id AND LOWER(s.tool_name) LIKE @tool)`
+      );
+      params.tool = `%${query.tool.toLowerCase()}%`;
+    }
+    const limit = Number.isInteger(query.limit) && query.limit > 0 ? query.limit : 100;
+    const sql = `SELECT r.* FROM runs r ${where.length ? `WHERE ${where.join(" AND ")}` : ""} ORDER BY r.started_at DESC LIMIT ${limit}`;
+    const rows = db.prepare(sql).all(params);
+    return rows.map(mapRow);
+  } finally {
+    db.close();
   }
 }
+var import_better_sqlite32;
+var init_query = __esm({
+  "packages/index-sqlite/src/query.ts"() {
+    import_better_sqlite32 = __toESM(require_lib());
+    init_schema();
+  }
+});
+
+// packages/index-sqlite/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  INDEX_DB_FILENAME: () => INDEX_DB_FILENAME,
+  INDEX_SCHEMA_VERSION: () => INDEX_SCHEMA_VERSION,
+  buildIndex: () => buildIndex,
+  cleanIndex: () => cleanIndex,
+  indexStatus: () => indexStatus,
+  isIndexStale: () => isIndexStale,
+  queryRuns: () => queryRuns,
+  rebuildIndex: () => rebuildIndex,
+  resolveIndexDbPath: () => resolveIndexDbPath
+});
+var init_src = __esm({
+  "packages/index-sqlite/src/index.ts"() {
+    init_types3();
+    init_builder();
+    init_query();
+  }
+});
+
+// package.json
+var version = "4.1.0";
+
+// packages/cli/src/list.ts
+init_advanced();
 
 // packages/cli/src/trace-dir-scale.ts
 var TRACE_COUNT_WARN = 1e3;
@@ -3319,8 +4813,8 @@ async function list(options = {}) {
     for (const fileName of files) {
       try {
         const filePath = td.getPath(fileName);
-        const meta = await extractMetadata(filePath);
-        metas.push(meta);
+        const meta2 = await extractMetadata(filePath);
+        metas.push(meta2);
       } catch {
       }
     }
@@ -3361,6 +4855,9 @@ async function list(options = {}) {
     process.exitCode = 1;
   }
 }
+
+// packages/cli/src/clean.ts
+init_advanced();
 function parseKeep(raw) {
   const trimmed = typeof raw === "string" ? raw.trim() : "";
   if (trimmed === "") {
@@ -3372,9 +4869,9 @@ function parseKeep(raw) {
   }
   return n;
 }
-function basisTimeMs(meta) {
-  const started = typeof meta.startedAt === "number" ? meta.startedAt : void 0;
-  const t = started ?? meta.createdAt.getTime();
+function basisTimeMs(meta2) {
+  const started = typeof meta2.startedAt === "number" ? meta2.startedAt : void 0;
+  const t = started ?? meta2.createdAt.getTime();
   return Number.isFinite(t) ? t : 0;
 }
 function stableSortNewestFirst(a, b) {
@@ -3516,6 +5013,18 @@ async function clean(options = {}) {
   }
 }
 
+// packages/cli/src/view.ts
+init_advanced();
+
+// packages/cli/src/read-run.ts
+init_advanced();
+
+// packages/core/src/entries/persisted.ts
+init_persisted_inspect_event();
+
+// packages/core/src/persisted/from-trace-event.ts
+init_correlation_metadata();
+
 // packages/core/src/persisted/token-usage.ts
 function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -3750,6 +5259,7 @@ function traceEventsToPersistedInspectEvents(events, options) {
 }
 
 // packages/core/src/persisted/to-inspect-event.ts
+init_persisted_inspect_event();
 function compactAttributes2(entries) {
   const out = {};
   for (const [key, value] of Object.entries(entries)) {
@@ -3887,6 +5397,9 @@ function persistedInspectEventsToInspectEvents(events, options) {
   return out;
 }
 
+// packages/core/src/entries/persisted.ts
+init_to_trace_event();
+
 // packages/core/src/logs/tree-builder.ts
 function inc(map, key) {
   map[key] = (map[key] ?? 0) + 1;
@@ -3974,6 +5487,9 @@ function persistedInspectEventsToRunTrees(events, options) {
   });
   return new TreeBuilder().build(inspectEvents);
 }
+
+// packages/core/src/readers/index.ts
+init_read_trace();
 var DEFAULT_MAX_TRACE_INPUT_BYTES = 10 * 1024 * 1024;
 var MIN_DETECTION_CONFIDENCE = 0.5;
 var AMBIGUOUS_CONFIDENCE_DELTA = 0.05;
@@ -5686,24 +7202,24 @@ function printSummary(summary) {
     );
   }
 }
-function printMetadata(meta) {
+function printMetadata(meta2) {
   console.log("Trace Metadata");
-  console.log(`ID: ${meta.runId}`);
-  console.log(`Name: ${meta.name ?? "unnamed"}`);
-  console.log(`Status: ${meta.status}`);
+  console.log(`ID: ${meta2.runId}`);
+  console.log(`Name: ${meta2.name ?? "unnamed"}`);
+  console.log(`Status: ${meta2.status}`);
   console.log(
-    `Started: ${meta.startedAt !== void 0 ? formatTimestamp(meta.startedAt) : "-"}`
+    `Started: ${meta2.startedAt !== void 0 ? formatTimestamp(meta2.startedAt) : "-"}`
   );
   console.log(
-    `Ended: ${meta.endedAt !== void 0 ? formatTimestamp(meta.endedAt) : "-"}`
+    `Ended: ${meta2.endedAt !== void 0 ? formatTimestamp(meta2.endedAt) : "-"}`
   );
   console.log(
-    `Duration: ${meta.durationMs !== void 0 ? formatDuration2(meta.durationMs) : "-"}`
+    `Duration: ${meta2.durationMs !== void 0 ? formatDuration2(meta2.durationMs) : "-"}`
   );
-  console.log(`Event count: ${meta.eventCount}`);
-  console.log(`File path: ${meta.filePath}`);
-  console.log(`File size: ${meta.fileSize}`);
-  console.log(`Created at: ${meta.createdAt.toISOString()}`);
+  console.log(`Event count: ${meta2.eventCount}`);
+  console.log(`File path: ${meta2.filePath}`);
+  console.log(`File size: ${meta2.fileSize}`);
+  console.log(`Created at: ${meta2.createdAt.toISOString()}`);
 }
 function filterErrorEvents(events) {
   return events.filter((e) => {
@@ -5772,11 +7288,11 @@ async function view(runId, options = {}) {
       return;
     }
     if (mode === "metadata") {
-      const meta = await extractMetadata(filePath);
+      const meta2 = await extractMetadata(filePath);
       if (options.json) {
-        console.log(JSON.stringify(meta, null, 2));
+        console.log(JSON.stringify(meta2, null, 2));
       } else {
-        printMetadata(meta);
+        printMetadata(meta2);
       }
       return;
     }
@@ -6153,7 +7669,11 @@ function matchMapping(eventName, mappings) {
   return bestKey ? mappings[bestKey] : void 0;
 }
 
+// packages/core/src/entries/logs.ts
+init_redactor();
+
 // packages/core/src/logs/normalizer.ts
+init_nanoid();
 function isFiniteNumber2(v) {
   return typeof v === "number" && Number.isFinite(v);
 }
@@ -6446,6 +7966,7 @@ function renderRunTree(tree, options) {
 function renderRunTrees(trees, options) {
   return trees.map((t) => renderRunTree(t, options)).join("\n\n");
 }
+init_redactor();
 
 // packages/core/src/logs/line-parser.ts
 function shiftLineNumbers(res, options) {
@@ -6483,6 +8004,7 @@ function parseLogLine(line, options = {}) {
 }
 
 // packages/core/src/logs/live-tree.ts
+init_redactor();
 var LiveLogAccumulator = class {
   #config;
   #format;
@@ -6936,10 +8458,15 @@ async function tail(options = {}) {
   }
 }
 
+// packages/cli/src/export.ts
+init_advanced();
+
 // packages/core/src/exporters/types.ts
 var EXPORT_PAYLOAD_VERSION = "0.1.2";
 
 // packages/core/src/exporters/redact-export.ts
+init_redactor();
+init_redaction_profiles();
 function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -7586,19 +9113,19 @@ function exportOpenInference(tree, options) {
     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 meta2 = ev.attributes;
+    if (meta2?.model !== void 0 && typeof meta2.model === "string") {
+      attrs["llm.model_name"] = meta2.model;
     }
-    const tokens = meta?.tokens;
+    const tokens = meta2?.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 (includeAttributes && meta2 && typeof meta2 === "object") {
+      for (const [k, v] of Object.entries(meta2)) {
         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;
@@ -7607,7 +9134,7 @@ function exportOpenInference(tree, options) {
     }
     let status;
     if (ev.status === "error") {
-      const msg = meta && typeof meta.error === "object" && meta.error !== null ? String(meta.error.message ?? "error") : "error";
+      const msg = meta2 && typeof meta2.error === "object" && meta2.error !== null ? String(meta2.error.message ?? "error") : "error";
       status = { code: "ERROR", message: msg.slice(0, maxLen) };
     } else if (ev.status === "ok") {
       status = { code: "OK" };
@@ -7697,19 +9224,19 @@ function exportOtlpJson(tree, options) {
     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 meta2 = ev.attributes;
+    if (meta2?.model !== void 0 && typeof meta2.model === "string") {
+      attrs.push(stringAttr("gen_ai.request.model", meta2.model.slice(0, maxLen)));
     }
-    const tokens = meta?.tokens;
+    const tokens = meta2?.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 (includeAttributes && meta2 && typeof meta2 === "object") {
+      for (const [k, v] of Object.entries(meta2)) {
         if (k === "tokens" || k === "model") continue;
         if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
           attrs.push(
@@ -7725,7 +9252,7 @@ function exportOtlpJson(tree, options) {
     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";
+      statusMessage = meta2 && typeof meta2.error === "object" && meta2.error !== null ? String(meta2.error.message ?? "error").slice(0, maxLen) : "error";
     } else if (ev.status === "ok") {
       statusCode = "STATUS_CODE_OK";
     }
@@ -8024,6 +9551,8 @@ function validateExport(result) {
 }
 
 // packages/core/src/report.ts
+init_timeline();
+init_what();
 function resolveTree(events, profile) {
   const tree = manualTraceEventsToRunTree(events);
   return profile === "local" ? tree : redactRunTreeForExport(tree, { redactionProfile: profile });
@@ -8265,11 +9794,14 @@ Trace directory: ${traceDir}`);
   }
 }
 
+// packages/cli/src/diff.ts
+init_advanced();
+
 // 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;
+function extractOutputPreview(meta2) {
+  if (meta2 === void 0) return void 0;
+  if ("outputPreview" in meta2) return meta2.outputPreview;
+  if ("resultPreview" in meta2) return meta2.resultPreview;
   return void 0;
 }
 function mapStepStatus2(s) {
@@ -8294,7 +9826,7 @@ function manualTraceEventsToComparableRun(events) {
   for (const e of events) {
     if (e.event !== "step_started") continue;
     const s = e;
-    const meta = s.metadata ? { ...s.metadata } : void 0;
+    const meta2 = s.metadata ? { ...s.metadata } : void 0;
     steps.set(s.stepId, {
       id: s.stepId,
       parentId: s.parentId,
@@ -8302,7 +9834,7 @@ function manualTraceEventsToComparableRun(events) {
       type: s.type,
       order: order++,
       timestamp: s.timestamp,
-      metadata: meta
+      metadata: meta2
     });
   }
   for (const e of events) {
@@ -8319,11 +9851,11 @@ function manualTraceEventsToComparableRun(events) {
   }
   const nodes = /* @__PURE__ */ new Map();
   for (const acc of steps.values()) {
-    let meta = acc.metadata ? { ...acc.metadata } : void 0;
+    let meta2 = acc.metadata ? { ...acc.metadata } : void 0;
     if (acc.parentId !== void 0 && !steps.has(acc.parentId)) {
-      meta = { ...meta ?? {}, agent_inspect_diff_parent_missing: true };
+      meta2 = { ...meta2 ?? {}, agent_inspect_diff_parent_missing: true };
     }
-    const outputPreview = extractOutputPreview(meta);
+    const outputPreview = extractOutputPreview(meta2);
     const sc = {
       id: acc.id,
       name: acc.name,
@@ -8331,7 +9863,7 @@ function manualTraceEventsToComparableRun(events) {
       status: mapStepStatus2(acc.status),
       durationMs: acc.durationMs,
       error: acc.errorMsg,
-      metadata: meta && Object.keys(meta).length > 0 ? meta : void 0,
+      metadata: meta2 && Object.keys(meta2).length > 0 ? meta2 : void 0,
       outputPreview,
       children: []
     };
@@ -8404,13 +9936,13 @@ function pairSteps(left, right) {
   return pairs;
 }
 function compareLeafSteps(L, R, segments, opts, out) {
-  const path20 = buildPath(segments);
+  const path22 = buildPath(segments);
   if (L.name !== R.name) {
     out.push({
       kind: "structure",
       severity: "warning",
       message: "Step name differs",
-      path: path20,
+      path: path22,
       left: L.name,
       right: R.name
     });
@@ -8420,7 +9952,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-type",
       severity: "warning",
       message: "Step type differs",
-      path: path20,
+      path: path22,
       left: L.type,
       right: R.type
     });
@@ -8430,7 +9962,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-status",
       severity: "warning",
       message: "Step status differs",
-      path: path20,
+      path: path22,
       left: L.status,
       right: R.status
     });
@@ -8442,7 +9974,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "error",
       severity: "error",
       message: "Step error message differs",
-      path: path20,
+      path: path22,
       left: le || void 0,
       right: re || void 0
     });
@@ -8460,20 +9992,20 @@ function compareLeafSteps(L, R, segments, opts, out) {
         kind: "duration",
         severity: "info",
         message: "Step duration differs",
-        path: path20,
+        path: path22,
         left: ld,
         right: rd
       });
     }
   }
   const lm = stableJson(L.metadata ?? {});
-  const rm3 = stableJson(R.metadata ?? {});
-  if (lm !== rm3) {
+  const rm4 = stableJson(R.metadata ?? {});
+  if (lm !== rm4) {
     out.push({
       kind: "metadata",
       severity: "info",
       message: "Step metadata differs",
-      path: path20,
+      path: path22,
       left: L.metadata,
       right: R.metadata
     });
@@ -8485,7 +10017,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "output",
       severity: "info",
       message: "Output preview differs",
-      path: path20,
+      path: path22,
       left: L.outputPreview,
       right: R.outputPreview
     });
@@ -8645,11 +10177,12 @@ function diffRuns(left, right, options) {
 }
 
 // packages/core/src/diff/renderer.ts
-function formatPath(path20) {
-  if (path20 === void 0 || path20.path.length === 0) {
+init_source();
+function formatPath(path22) {
+  if (path22 === void 0 || path22.path.length === 0) {
     return "(run)";
   }
-  return path20.path.map((s) => s.name).join(" > ");
+  return path22.path.map((s) => s.name).join(" > ");
 }
 function formatValue(v, verbose) {
   if (v === void 0) return "(undefined)";
@@ -8831,6 +10364,7 @@ Trace directory: ${traceDir}`
 }
 
 // packages/cli/src/timeline.ts
+init_advanced();
 async function timelineCommand(runId, options = {}) {
   const id = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "";
   if (id === "") {
@@ -8867,6 +10401,7 @@ async function timelineCommand(runId, options = {}) {
 }
 
 // packages/cli/src/stats.ts
+init_advanced();
 async function statsCommand(options = {}) {
   try {
     const traceDir = resolveTraceDir({ dir: options.dir });
@@ -8930,6 +10465,7 @@ async function statsCommand(options = {}) {
 }
 
 // packages/cli/src/search.ts
+init_advanced();
 function parseLimit2(raw) {
   if (raw === void 0 || raw.trim() === "") return 50;
   const n = Number.parseInt(raw, 10);
@@ -9013,6 +10549,7 @@ async function searchCommand(options = {}) {
 }
 
 // packages/cli/src/sessions.ts
+init_advanced();
 async function loadSessionIndex(traceDir, correlateGroup) {
   const td = new TraceDirectory({ dir: traceDir });
   const files = await td.list();
@@ -9191,6 +10728,7 @@ async function sessionCommand(sessionId, options = {}) {
 }
 
 // packages/cli/src/what.ts
+init_advanced();
 async function whatCommand(runId, options = {}) {
   const id = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "";
   if (id === "") {
@@ -9222,6 +10760,9 @@ async function whatCommand(runId, options = {}) {
   }
   console.log(renderRunWhat(summary, { correlation: !options.noCorrelation }));
 }
+
+// packages/cli/src/report.ts
+init_advanced();
 function parseReportFormat(s) {
   const v = (s ?? "markdown").trim().toLowerCase();
   if (v === "markdown" || v === "html") {
@@ -9304,6 +10845,9 @@ async function reportCommand(runId, options = {}) {
     console.log(result.content);
   }
 }
+
+// packages/cli/src/redact.ts
+init_advanced();
 var DEFAULT_REDACT_KEYS2 = [
   "authorization",
   "cookie",
@@ -9531,17 +11075,17 @@ function applyRule(rule, value, replacement) {
   }
   return value;
 }
-function childPath(path20, key) {
+function childPath(path22, key) {
   if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) {
-    return path20 ? `${path20}.${key}` : key;
+    return path22 ? `${path22}.${key}` : key;
   }
-  return `${path20 || "$"}[${JSON.stringify(key)}]`;
+  return `${path22 || "$"}[${JSON.stringify(key)}]`;
 }
-function indexPath(path20, index) {
-  return `${path20 || "$"}[${index}]`;
+function indexPath(path22, index) {
+  return `${path22 || "$"}[${index}]`;
 }
-function makeFinding(path20, detector, action, matchKind, severity = "warning", preview) {
-  return preview === void 0 ? { path: path20, detector, action, severity, matchKind } : { path: path20, detector, action, severity, matchKind, preview };
+function makeFinding(path22, detector, action, matchKind, severity = "warning", preview) {
+  return preview === void 0 ? { path: path22, detector, action, severity, matchKind } : { path: path22, detector, action, severity, matchKind, preview };
 }
 function createRedactionProfile(profile = "local") {
   switch (profile) {
@@ -9610,11 +11154,11 @@ var Redactor2 = class {
   #recordFinding(state, finding) {
     if (this.#collectFindings) state.findings.push(finding);
   }
-  #redactValue(value, key, path20, depth, state) {
+  #redactValue(value, key, path22, depth, state) {
     if (depth > this.#maxDepth) {
       this.#recordFinding(
         state,
-        makeFinding(path20, "structure.maxDepth", "truncate", "value", "warning")
+        makeFinding(path22, "structure.maxDepth", "truncate", "value", "warning")
       );
       return "[Truncated]";
     }
@@ -9623,19 +11167,19 @@ var Redactor2 = class {
       if (rule) {
         this.#recordFinding(
           state,
-          makeFinding(path20, `key.${rule.key}`, actionForRule(rule), "key", "warning")
+          makeFinding(path22, `key.${rule.key}`, actionForRule(rule), "key", "warning")
         );
         return applyRule(rule, value, this.#replacement);
       }
     }
     for (const detector of this.#detectors) {
-      const detections = detector.detect({ path: path20, key, value });
+      const detections = detector.detect({ path: path22, key, value });
       for (const detection of detections) {
         const action = detection.action ?? "replace";
         this.#recordFinding(
           state,
           makeFinding(
-            path20,
+            path22,
             detector.id,
             action,
             detection.matchKind ?? detector.matchKind ?? "custom",
@@ -9653,7 +11197,7 @@ var Redactor2 = class {
       const out = [];
       state.seen.set(value, out);
       value.forEach((item, index) => {
-        out[index] = this.#redactValue(item, void 0, indexPath(path20, index), depth + 1, state);
+        out[index] = this.#redactValue(item, void 0, indexPath(path22, index), depth + 1, state);
       });
       return out;
     }
@@ -9665,7 +11209,7 @@ var Redactor2 = class {
         out[entryKey] = this.#redactValue(
           entryValue,
           entryKey,
-          childPath(path20 === "$" ? "" : path20, entryKey),
+          childPath(path22 === "$" ? "" : path22, entryKey),
           depth + 1,
           state
         );
@@ -9681,6 +11225,9 @@ function createRedactor(options) {
 function redact(value, options) {
   return createRedactor(options).redact(value);
 }
+
+// packages/cli/src/trace-input.ts
+init_advanced();
 async function readStdin(stdin) {
   stdin.setEncoding("utf8");
   let content = "";
@@ -9821,6 +11368,7 @@ async function redactCommand(target, options = {}, stdin = process.stdin) {
 }
 
 // packages/cli/src/explain.ts
+init_advanced();
 function parseRedactionProfile4(value) {
   const profile = (value ?? "local").trim().toLowerCase();
   if (profile === "local" || profile === "share" || profile === "strict") {
@@ -9947,6 +11495,9 @@ async function explainCommand(target, options = {}, stdin = process.stdin) {
     console.error(message);
   }
 }
+
+// packages/cli/src/open.ts
+init_advanced();
 async function readStdin2(stdin) {
   stdin.setEncoding("utf8");
   let content = "";
@@ -10090,6 +11641,9 @@ async function openCommand(input3, options = {}, stdin = process.stdin) {
     }
   }
 }
+
+// packages/cli/src/migrate.ts
+init_advanced();
 function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -10269,6 +11823,7 @@ async function migrateCommand(input3, options = {}) {
     process.exitCode = 1;
   }
 }
+init_advanced();
 
 // packages/core/src/checks/index.ts
 var SEVERITY_RANK = {
@@ -10537,7 +12092,7 @@ function stripPrefix(name, prefixes) {
   }
   return name;
 }
-function eventEvidence(event, path20) {
+function eventEvidence(event, path22) {
   return {
     runId: event.runId,
     eventId: event.eventId,
@@ -10547,7 +12102,7 @@ function eventEvidence(event, path20) {
     kind: event.kind,
     name: event.name,
     status: event.status,
-    ...path20 ? { path: path20 } : {}
+    ...path22 ? { path: path22 } : {}
   };
 }
 function runEvidence(run) {
@@ -10610,9 +12165,9 @@ function eventEndMs(event) {
 function normalizedKey(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]/g, "");
 }
-function lastPathSegment(path20) {
-  const parts = path20.split(".");
-  return parts[parts.length - 1] ?? path20;
+function lastPathSegment(path22) {
+  const parts = path22.split(".");
+  return parts[parts.length - 1] ?? path22;
 }
 function valueType(value) {
   if (Array.isArray(value)) return "array";
@@ -10626,12 +12181,12 @@ function serializedByteLength(value) {
     return void 0;
   }
 }
-function pushValueEntries(entries, event, value, path20, key, depth = 0) {
-  entries.push({ event, path: path20, key, value });
+function pushValueEntries(entries, event, value, path22, key, depth = 0) {
+  entries.push({ event, path: path22, key, value });
   if (depth >= 8) return;
   if (Array.isArray(value)) {
     for (const [index, item] of value.entries()) {
-      pushValueEntries(entries, event, item, `${path20}.${index}`, String(index), depth + 1);
+      pushValueEntries(entries, event, item, `${path22}.${index}`, String(index), depth + 1);
     }
     return;
   }
@@ -10641,7 +12196,7 @@ function pushValueEntries(entries, event, value, path20, key, depth = 0) {
       entries,
       event,
       value[nestedKey],
-      `${path20}.${nestedKey}`,
+      `${path22}.${nestedKey}`,
       nestedKey,
       depth + 1
     );
@@ -10722,9 +12277,9 @@ function eventDurationMs(event) {
 }
 function treeShape(nodes) {
   const lines = [];
-  const visit = (node, path20) => {
-    lines.push(`${path20}:${node.event.kind}:${node.event.name}:${node.event.status ?? "unknown"}`);
-    node.children.forEach((child, index) => visit(child, `${path20}.${index}`));
+  const visit = (node, path22) => {
+    lines.push(`${path22}:${node.event.kind}:${node.event.name}:${node.event.status ?? "unknown"}`);
+    node.children.forEach((child, index) => visit(child, `${path22}.${index}`));
   };
   nodes.forEach((node, index) => visit(node, String(index)));
   return lines;
@@ -10773,9 +12328,9 @@ function retrievalShape(context) {
 function guardrailShape(context) {
   return guardrailEvents(context).map((event) => signalName(event, ["guardrailName", "guardrail", "guardrailId"], ["guardrail:"])).sort((a, b) => a.localeCompare(b));
 }
-function firstEvidenceForKind(context, kind, path20) {
+function firstEvidenceForKind(context, kind, path22) {
   const event = context.events.find((candidate) => candidate.kind === kind);
-  return event ? [eventEvidence(event, path20)] : runEvidence(context.selectedRun);
+  return event ? [eventEvidence(event, path22)] : runEvidence(context.selectedRun);
 }
 function baselineDiffFinding(message, evidence, expected, actual) {
   return failFinding("baseline.regression", message, evidence, expected, actual);
@@ -11125,13 +12680,13 @@ function createStructureCycleRule() {
       const seenCycles = /* @__PURE__ */ new Set();
       const findings = [];
       for (const event of [...context.events].sort((a, b) => a.eventId.localeCompare(b.eventId))) {
-        const path20 = [];
+        const path22 = [];
         const seenAt = /* @__PURE__ */ new Map();
         let current = event;
         while (current) {
           const existing = seenAt.get(current.eventId);
           if (existing !== void 0) {
-            const cycle = path20.slice(existing);
+            const cycle = path22.slice(existing);
             const key = cycle.map((item) => item.eventId).sort().join("\0");
             if (!seenCycles.has(key)) {
               seenCycles.add(key);
@@ -11147,8 +12702,8 @@ function createStructureCycleRule() {
             }
             break;
           }
-          seenAt.set(current.eventId, path20.length);
-          path20.push(current);
+          seenAt.set(current.eventId, path22.length);
+          path22.push(current);
           current = current.parentId ? byId.get(current.parentId) : void 0;
         }
       }
@@ -11945,23 +13500,23 @@ function evaluatePromptInjection(text, options = {}) {
   }
   return fail(ruleId, `Matched ${evidence.length} injection pattern(s).`, evidence, "warning");
 }
-function validateSchemaField(value, field, path20, evidence) {
+function validateSchemaField(value, field, path22, evidence) {
   const ruleId = "guardrail.structured-output";
   if (field.type) {
     const actual = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
     if (actual !== field.type) {
-      evidence.push({ ruleId, path: path20, preview: `expected ${field.type}, got ${actual}` });
+      evidence.push({ ruleId, path: path22, preview: `expected ${field.type}, got ${actual}` });
       return;
     }
   }
   if (field.enum && !field.enum.some((item) => Object.is(item, value))) {
-    evidence.push({ ruleId, path: path20, preview: "value not in enum" });
+    evidence.push({ ruleId, path: path22, preview: "value not in enum" });
   }
   if (field.type === "object" && field.required && value && typeof value === "object" && !Array.isArray(value)) {
     const record = value;
     for (const key of field.required) {
       if (!(key in record)) {
-        evidence.push({ ruleId, path: `${path20}.${key}`, preview: "missing required key" });
+        evidence.push({ ruleId, path: `${path22}.${key}`, preview: "missing required key" });
       }
     }
   }
@@ -12446,10 +14001,10 @@ function printHuman(result) {
     console.log(`- ${diagnostic4.code}: ${diagnostic4.message}`);
   }
   for (const finding of result.findings) {
-    const path20 = finding.evidence[0]?.path;
+    const path22 = finding.evidence[0]?.path;
     const run = finding.evidence[0]?.runId;
     const runPrefix = run ? `[${run}] ` : "";
-    console.log(`- ${runPrefix}${finding.ruleId}: ${finding.message}${path20 ? ` (${path20})` : ""}`);
+    console.log(`- ${runPrefix}${finding.ruleId}: ${finding.message}${path22 ? ` (${path22})` : ""}`);
   }
 }
 function readErrorResult(error) {
@@ -12491,9 +14046,9 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
         correlateByGroupId: options.correlateGroup === true
       });
       const perRun = [];
-      for (const meta of scoped.metas) {
+      for (const meta2 of scoped.metas) {
         const read = await openTrace(
-          { type: "file", path: meta.filePath },
+          { type: "file", path: meta2.filePath },
           {
             ...options.format !== void 0 ? { format: options.format } : {}
           }
@@ -12505,7 +14060,7 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
               {
                 rules: built.rules,
                 select: built.select,
-                runId: meta.runId
+                runId: meta2.runId
               }
             ),
             read,
@@ -12563,6 +14118,9 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
   else printHuman(result);
 }
 
+// packages/viewer/src/server.ts
+init_advanced();
+
 // packages/viewer/src/html.ts
 var viewerIndexHtml = `<!DOCTYPE html>
 <html lang="en">
@@ -12663,13 +14221,13 @@ function createViewerServer(options = {}) {
         return sendJson(
           res,
           200,
-          metas.map((meta) => ({
-            runId: meta.runId,
-            name: meta.name,
-            status: meta.status,
-            file: path14__default.default.basename(meta.filePath),
-            startedAt: meta.startedAt,
-            durationMs: meta.durationMs
+          metas.map((meta2) => ({
+            runId: meta2.runId,
+            name: meta2.name,
+            status: meta2.status,
+            file: path14__default.default.basename(meta2.filePath),
+            startedAt: meta2.startedAt,
+            durationMs: meta2.durationMs
           }))
         );
       }
@@ -12712,9 +14270,9 @@ function createViewerServer(options = {}) {
           files,
           (fileName) => td.getPath(fileName)
         );
-        const meta = metas.find((item) => item.runId === runId);
-        if (!meta) return notFound(res, `Run not found: ${runId}`);
-        const read = await openTrace({ type: "file", path: meta.filePath });
+        const meta2 = metas.find((item) => item.runId === runId);
+        if (!meta2) return notFound(res, `Run not found: ${runId}`);
+        const read = await openTrace({ type: "file", path: meta2.filePath });
         const run = read.runs.find((item) => item.runId === runId) ?? read.runs[0];
         return sendJson(res, 200, {
           runId,
@@ -12734,9 +14292,9 @@ function createViewerServer(options = {}) {
           files,
           (fileName) => td.getPath(fileName)
         );
-        const meta = metas.find((item) => item.runId === runId);
-        if (!meta) return notFound(res, `Run not found: ${runId}`);
-        const read = await openTrace({ type: "file", path: meta.filePath });
+        const meta2 = metas.find((item) => item.runId === runId);
+        if (!meta2) return notFound(res, `Run not found: ${runId}`);
+        const read = await openTrace({ type: "file", path: meta2.filePath });
         const legacyEvents = persistedInspectEventsToTraceEvents(
           boundedEvents(read.events, maxEvents)
         );
@@ -12752,9 +14310,9 @@ function createViewerServer(options = {}) {
           files,
           (fileName) => td.getPath(fileName)
         );
-        const meta = metas.find((item) => item.runId === runId);
-        if (!meta) return notFound(res, `Run not found: ${runId}`);
-        const read = await openTrace({ type: "file", path: meta.filePath });
+        const meta2 = metas.find((item) => item.runId === runId);
+        if (!meta2) return notFound(res, `Run not found: ${runId}`);
+        const read = await openTrace({ type: "file", path: meta2.filePath });
         const result = runTraceChecks(
           { read },
           { rules: [createRunStatusRule()], select: ["run.status"], runId }
@@ -12987,10 +14545,10 @@ async function evalRun(input3, options = {}) {
     diagnostics: []
   };
 }
-function evidenceForRun(run, path20) {
-  return [{ runId: run.runId, ...path20 !== void 0 ? { path: path20 } : {} }];
+function evidenceForRun(run, path22) {
+  return [{ runId: run.runId, ...path22 !== void 0 ? { path: path22 } : {} }];
 }
-function evidenceForEvent(event, path20) {
+function evidenceForEvent(event, path22) {
   return [
     {
       runId: event.runId,
@@ -12998,7 +14556,7 @@ function evidenceForEvent(event, path20) {
       ...event.parentId !== void 0 ? { parentId: event.parentId } : {},
       kind: event.kind,
       name: event.name,
-      ...path20 !== void 0 ? { path: path20 } : {}
+      ...path22 !== void 0 ? { path: path22 } : {}
     }
   ];
 }
@@ -13156,9 +14714,9 @@ function collectTextFields(nodes, keys, preferredKinds = []) {
 function tokenize(text) {
   return [...text.toLowerCase().matchAll(/[a-z0-9][a-z0-9'-]{2,}/g)].map((match) => match[0].replace(/^['-]+|['-]+$/g, "")).filter((token) => token.length > 2 && !STOP_WORDS.has(token));
 }
-function firstEvidence(fields, run, path20) {
+function firstEvidence(fields, run, path22) {
   const first = fields[0];
-  return first === void 0 ? evidenceForRun(run, path20) : evidenceForEvent(first.node.event, first.path);
+  return first === void 0 ? evidenceForRun(run, path22) : evidenceForEvent(first.node.event, first.path);
 }
 function collectSourceIds(nodes, keys) {
   const wanted = keySet(keys);
@@ -13535,8 +15093,8 @@ function renderEvalMarkdown(result) {
   if (result.findings.length > 0) {
     lines.push("", "## Findings");
     for (const finding of result.findings) {
-      const path20 = finding.evidence[0]?.path;
-      lines.push(`- ${finding.ruleId}: ${finding.message}${path20 ? ` (${path20})` : ""}`);
+      const path22 = finding.evidence[0]?.path;
+      lines.push(`- ${finding.ruleId}: ${finding.message}${path22 ? ` (${path22})` : ""}`);
     }
   }
   return `${lines.join("\n")}
@@ -13729,8 +15287,8 @@ function printHuman2(result) {
     console.log(`- ${diagnostic4.code}: ${diagnostic4.message}`);
   }
   for (const finding of result.findings) {
-    const path20 = finding.evidence[0]?.path;
-    console.log(`- ${finding.ruleId}: ${finding.message}${path20 ? ` (${path20})` : ""}`);
+    const path22 = finding.evidence[0]?.path;
+    console.log(`- ${finding.ruleId}: ${finding.message}${path22 ? ` (${path22})` : ""}`);
   }
 }
 function readErrorResult2(error) {
@@ -13968,8 +15526,8 @@ function printHuman3(result) {
     console.log(`- ${diagnostic4.code}: ${diagnostic4.message}`);
   }
   for (const finding of result.findings) {
-    const path20 = finding.evidence[0]?.path;
-    console.log(`- ${finding.ruleId}: ${finding.message}${path20 ? ` (${path20})` : ""}`);
+    const path22 = finding.evidence[0]?.path;
+    console.log(`- ${finding.ruleId}: ${finding.message}${path22 ? ` (${path22})` : ""}`);
   }
   console.log(`Note: ${result.note}`);
 }
@@ -14088,8 +15646,8 @@ function renderCheckSection(result) {
     `Diagnostics: ${result.diagnostics.length}`
   ];
   for (const finding of result.findings.slice(0, 10)) {
-    const path20 = finding.evidence[0]?.path ?? "(run)";
-    lines.push(`- ${finding.ruleId}: ${finding.message} (${path20})`);
+    const path22 = finding.evidence[0]?.path ?? "(run)";
+    lines.push(`- ${finding.ruleId}: ${finding.message} (${path22})`);
   }
   for (const diagnostic4 of result.diagnostics.slice(0, 10)) {
     lines.push(`- ${diagnostic4.code}: ${diagnostic4.message}`);
@@ -15092,6 +16650,7 @@ Summary: ${failed} failed, ${warned} warnings`);
 }
 
 // packages/adapter-sdk/src/indexer.ts
+init_advanced();
 function defineIndexer(indexer) {
   if (!indexer.id.trim()) throw new Error("indexer id is required");
   return indexer;
@@ -15126,12 +16685,12 @@ function createTraceDirectoryIndexer() {
         slice,
         (fileName) => td.getPath(fileName)
       );
-      const entries = metas.map((meta) => ({
-        runId: meta.runId,
-        path: meta.filePath,
-        name: meta.name,
-        startedAt: meta.startedAt,
-        status: meta.status
+      const entries = metas.map((meta2) => ({
+        runId: meta2.runId,
+        path: meta2.filePath,
+        name: meta2.name,
+        startedAt: meta2.startedAt,
+        status: meta2.status
       })).sort((a, b) => a.runId.localeCompare(b.runId));
       if (entries.length < slice.length) {
         warnings.push(
@@ -15149,6 +16708,7 @@ function createTraceDirectoryIndexer() {
 }
 
 // packages/cli/src/index-cmd.ts
+init_advanced();
 var INDEX_FILENAME = ".agent-inspect-index.json";
 function traceIndexPath(traceDir) {
   return path14__default.default.join(traceDir, INDEX_FILENAME);
@@ -15259,6 +16819,144 @@ async function indexCleanCommand(options = {}) {
   }
 }
 
+// packages/cli/src/index-sqlite-cmd.ts
+init_advanced();
+var PACKAGE = "@agent-inspect/index-sqlite";
+function isModuleNotFound2(e) {
+  return e !== null && typeof e === "object" && "code" in e && (e.code === "ERR_MODULE_NOT_FOUND" || e.code === "MODULE_NOT_FOUND");
+}
+async function loadIndexSqlite() {
+  try {
+    return await Promise.resolve().then(() => (init_src(), src_exports));
+  } catch (e) {
+    if (isModuleNotFound2(e)) {
+      console.error(
+        `The optional SQLite index is not installed. Run: npm install ${PACKAGE}`
+      );
+      process.exitCode = 1;
+      return null;
+    }
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`[AgentInspect] failed to load ${PACKAGE}: ${msg}`);
+    process.exitCode = 1;
+    return null;
+  }
+}
+function parsePositiveInt(raw, flag) {
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${flag} must be a positive integer.`);
+  }
+  return parsed;
+}
+async function newestTraceMtimeMs(traceDir) {
+  let newest = 0;
+  try {
+    const files = await promises.readdir(traceDir);
+    for (const file of files) {
+      if (!file.endsWith(".jsonl")) continue;
+      try {
+        const s = await promises.stat(path14__default.default.join(traceDir, file));
+        if (s.mtimeMs > newest) newest = s.mtimeMs;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return newest;
+}
+async function indexSqliteBuildCommand(options = {}) {
+  const mod = await loadIndexSqlite();
+  if (!mod) return;
+  const result = await mod.buildIndex({
+    traceDir: options.dir,
+    maxRuns: parsePositiveInt(options.maxRuns, "--max-runs")
+  });
+  if (options.json) {
+    console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+    return;
+  }
+  console.log(`Built SQLite index: ${result.dbPath}`);
+  console.log(`Runs: ${result.runs}  Steps: ${result.steps}  Errors: ${result.errors}`);
+  for (const warning of result.warnings) console.log(`warning: ${warning}`);
+}
+async function indexSqliteStatusCommand(options = {}) {
+  const mod = await loadIndexSqlite();
+  if (!mod) return;
+  const traceDir = resolveTraceDir({ dir: options.dir });
+  const dbPath = mod.resolveIndexDbPath(traceDir);
+  const status = mod.indexStatus(dbPath);
+  const stale = mod.isIndexStale(dbPath, await newestTraceMtimeMs(traceDir));
+  if (options.json) {
+    console.log(JSON.stringify({ ok: true, traceDir, stale, ...status }, null, 2));
+    return;
+  }
+  if (!status.exists) {
+    console.log(`No SQLite index at ${dbPath}`);
+    console.log("Run: agent-inspect index sqlite build");
+    return;
+  }
+  console.log(`Index: ${status.dbPath}`);
+  console.log(`Healthy: ${status.healthy ? "yes" : "no"}`);
+  console.log(`Built: ${status.builtAt ?? "unknown"}`);
+  console.log(`Runs: ${status.runs}  Steps: ${status.steps}`);
+  console.log(`Stale: ${stale ? "yes" : "no"}`);
+}
+async function indexSqliteQueryCommand(options = {}) {
+  const mod = await loadIndexSqlite();
+  if (!mod) return;
+  const traceDir = resolveTraceDir({ dir: options.dir });
+  const dbPath = mod.resolveIndexDbPath(traceDir);
+  const status = mod.indexStatus(dbPath);
+  if (!status.exists || !status.healthy) {
+    if (options.json) {
+      console.log(JSON.stringify({ ok: false, reason: "index-missing", dbPath }, null, 2));
+    } else {
+      console.log("No usable SQLite index. Run: agent-inspect index sqlite build");
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const rows = mod.queryRuns(dbPath, {
+    status: options.status,
+    sessionId: options.session,
+    name: options.name,
+    kind: options.kind,
+    tool: options.tool,
+    limit: parsePositiveInt(options.limit, "--limit")
+  });
+  if (options.json) {
+    console.log(JSON.stringify({ ok: true, count: rows.length, runs: rows }, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log("No matching runs.");
+    return;
+  }
+  for (const run of rows) {
+    const parts = [
+      run.runId,
+      run.status ?? "unknown",
+      run.name ?? "",
+      run.durationMs != null ? `${run.durationMs}ms` : ""
+    ].filter((p) => p !== "");
+    console.log(parts.join("  "));
+  }
+}
+async function indexSqliteCleanCommand(options = {}) {
+  const mod = await loadIndexSqlite();
+  if (!mod) return;
+  const traceDir = resolveTraceDir({ dir: options.dir });
+  const dbPath = mod.resolveIndexDbPath(traceDir);
+  await mod.cleanIndex(dbPath);
+  if (options.json) {
+    console.log(JSON.stringify({ ok: true, removed: dbPath }, null, 2));
+    return;
+  }
+  console.log(`Removed SQLite index: ${dbPath}`);
+}
+
 // packages/core/src/workspace/types.ts
 var WORKSPACE_SCHEMA_VERSION = "1.0";
 var WORKSPACE_DIR_NAME = ".agent-inspect";
@@ -16192,6 +17890,31 @@ function createCliProgram() {
   indexCmd.command("clean").description("Remove the local index file").option("--dir <path>", "trace directory").option("--json", "print JSON result").action((opts) => {
     runCommand(() => indexCleanCommand(opts));
   });
+  const sqliteCmd = indexCmd.command("sqlite").description(
+    "Optional SQLite-backed trace index (requires @agent-inspect/index-sqlite)"
+  );
+  sqliteCmd.command("build").description("Build or rebuild the local SQLite index").option("--dir <path>", "trace directory").option("--max-runs <n>", "cap indexed trace files (default 10000)").option("--json", "print JSON result").action((opts) => {
+    runCommand(() => indexSqliteBuildCommand(opts));
+  });
+  sqliteCmd.command("rebuild").description("Alias for build (full, idempotent rebuild)").option("--dir <path>", "trace directory").option("--max-runs <n>", "cap indexed trace files (default 10000)").option("--json", "print JSON result").action((opts) => {
+    runCommand(() => indexSqliteBuildCommand(opts));
+  });
+  sqliteCmd.command("status").description("Show SQLite index health, counts, and staleness").option("--dir <path>", "trace directory").option("--json", "print JSON result").action((opts) => {
+    runCommand(() => indexSqliteStatusCommand(opts));
+  });
+  sqliteCmd.command("query").description("Query indexed runs (fast; falls back with a hint if absent)").option("--dir <path>", "trace directory").addOption(
+    new commander.Option("--status <status>", "filter by run status").choices([
+      "success",
+      "error",
+      "running",
+      "unknown"
+    ])
+  ).option("--session <id>", "filter by session id").option("--name <query>", "substring match on run name").option("--kind <kind>", "match runs containing a step of this kind").option("--tool <query>", "match runs containing a tool step (substring)").option("--limit <n>", "max results (default 100)").option("--json", "print JSON result").action((opts) => {
+    runCommand(() => indexSqliteQueryCommand(opts));
+  });
+  sqliteCmd.command("clean").description("Remove the SQLite index (traces are never touched)").option("--dir <path>", "trace directory").option("--json", "print JSON result").action((opts) => {
+    runCommand(() => indexSqliteCleanCommand(opts));
+  });
   const workspaceCmd = program.command("workspace").description("Manage a project-local AgentInspect workspace (.agent-inspect)");
   workspaceCmd.command("init").description("Create or adopt a local workspace (never deletes traces)").option("--project <name>", "project name (default: directory name)").addOption(
     new commander.Option("--redaction-profile <profile>", "default redaction posture").choices([