agent-inspect 5.0.0 → 5.1.0

package/packages/cli/dist/index.cjs

@@ -2100,7 +2100,7 @@ function buildRunSummary(events) {
   }
   let totalSteps = 0;
   let llmSteps = 0;
-  let toolSteps = 0;
+  let toolSteps2 = 0;
   let logicSteps = 0;
   let errorSteps = 0;
   let maxDepth = 0;
@@ -2130,7 +2130,7 @@ function buildRunSummary(events) {
   for (const [id, s] of steps.entries()) {
     totalSteps += 1;
     if (s.type === "llm") llmSteps += 1;
-    else if (s.type === "tool") toolSteps += 1;
+    else if (s.type === "tool") toolSteps2 += 1;
     else logicSteps += 1;
     if (s.status === "error") errorSteps += 1;
     const depth = computeDepth(id);
@@ -2164,7 +2164,7 @@ function buildRunSummary(events) {
     durationMs: durationMs2,
     totalSteps,
     llmSteps,
-    toolSteps,
+    toolSteps: toolSteps2,
     logicSteps,
     errorSteps,
     maxDepth,
@@ -3786,12 +3786,12 @@ function buildCriticalPath(runs, handoffs) {
     handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.from)
   );
   const ordered = [...runs].sort(compareRuns);
-  const path30 = [];
+  const path31 = [];
   const visited = /* @__PURE__ */ new Set();
   const pushRun = (run, confidence, source) => {
     if (visited.has(run.runId)) return;
     visited.add(run.runId);
-    path30.push({
+    path31.push({
       runId: run.runId,
       name: run.name,
       startedAt: run.startedAt,
@@ -3816,7 +3816,7 @@ function buildCriticalPath(runs, handoffs) {
     const confidence = explicitTargets.has(run.runId) || explicitSources.has(run.runId) ? "explicit" : "correlated";
     pushRun(run, confidence, confidence === "explicit" ? "manual" : "inferred");
   }
-  return path30;
+  return path31;
 }
 function metaRunIdMatches(run, token, runById) {
   const meta2 = extractSessionWorkflowMetadata(run.metadata);
@@ -4716,7 +4716,7 @@ function stripPrefix(name, prefixes) {
   }
   return name;
 }
-function eventEvidence(event, path30) {
+function eventEvidence(event, path31) {
   return {
     runId: event.runId,
     eventId: event.eventId,
@@ -4726,7 +4726,7 @@ function eventEvidence(event, path30) {
     kind: event.kind,
     name: event.name,
     status: event.status,
-    ...path30 ? { path: path30 } : {}
+    ...path31 ? { path: path31 } : {}
   };
 }
 function runEvidence(run) {
@@ -4789,9 +4789,9 @@ function eventEndMs(event) {
 function normalizedKey(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]/g, "");
 }
-function lastPathSegment(path30) {
-  const parts = path30.split(".");
-  return parts[parts.length - 1] ?? path30;
+function lastPathSegment(path31) {
+  const parts = path31.split(".");
+  return parts[parts.length - 1] ?? path31;
 }
 function valueType(value) {
   if (Array.isArray(value)) return "array";
@@ -4805,12 +4805,12 @@ function serializedByteLength(value) {
     return void 0;
   }
 }
-function pushValueEntries(entries, event, value, path30, key, depth = 0) {
-  entries.push({ event, path: path30, key, value });
+function pushValueEntries(entries, event, value, path31, key, depth = 0) {
+  entries.push({ event, path: path31, key, value });
   if (depth >= 8) return;
   if (Array.isArray(value)) {
     for (const [index, item] of value.entries()) {
-      pushValueEntries(entries, event, item, `${path30}.${index}`, String(index), depth + 1);
+      pushValueEntries(entries, event, item, `${path31}.${index}`, String(index), depth + 1);
     }
     return;
   }
@@ -4820,7 +4820,7 @@ function pushValueEntries(entries, event, value, path30, key, depth = 0) {
       entries,
       event,
       value[nestedKey],
-      `${path30}.${nestedKey}`,
+      `${path31}.${nestedKey}`,
       nestedKey,
       depth + 1
     );
@@ -4901,9 +4901,9 @@ function eventDurationMs(event) {
 }
 function treeShape(nodes) {
   const lines = [];
-  const visit = (node, path30) => {
-    lines.push(`${path30}:${node.event.kind}:${node.event.name}:${node.event.status ?? "unknown"}`);
-    node.children.forEach((child, index) => visit(child, `${path30}.${index}`));
+  const visit = (node, path31) => {
+    lines.push(`${path31}:${node.event.kind}:${node.event.name}:${node.event.status ?? "unknown"}`);
+    node.children.forEach((child, index) => visit(child, `${path31}.${index}`));
   };
   nodes.forEach((node, index) => visit(node, String(index)));
   return lines;
@@ -4952,9 +4952,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, path30) {
+function firstEvidenceForKind(context, kind, path31) {
   const event = context.events.find((candidate) => candidate.kind === kind);
-  return event ? [eventEvidence(event, path30)] : runEvidence(context.selectedRun);
+  return event ? [eventEvidence(event, path31)] : runEvidence(context.selectedRun);
 }
 function baselineDiffFinding(message, evidence, expected, actual) {
   return failFinding("baseline.regression", message, evidence, expected, actual);
@@ -5304,13 +5304,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 path30 = [];
+        const path31 = [];
         const seenAt = /* @__PURE__ */ new Map();
         let current = event;
         while (current) {
           const existing = seenAt.get(current.eventId);
           if (existing !== void 0) {
-            const cycle = path30.slice(existing);
+            const cycle = path31.slice(existing);
             const key = cycle.map((item) => item.eventId).sort().join("\0");
             if (!seenCycles.has(key)) {
               seenCycles.add(key);
@@ -5326,8 +5326,8 @@ function createStructureCycleRule() {
             }
             break;
           }
-          seenAt.set(current.eventId, path30.length);
-          path30.push(current);
+          seenAt.set(current.eventId, path31.length);
+          path31.push(current);
           current = current.parentId ? byId.get(current.parentId) : void 0;
         }
       }
@@ -8275,6 +8275,682 @@ var init_suite = __esm({
   }
 });
 
+// packages/core/src/cohort/types.ts
+var COHORT_METRIC_IDS;
+var init_types5 = __esm({
+  "packages/core/src/cohort/types.ts"() {
+    COHORT_METRIC_IDS = [
+      "errorRate",
+      "duration",
+      "toolChoice",
+      "toolOrdering",
+      "llmCallCount",
+      "tokenUsage",
+      "retryCount",
+      "observationFailure",
+      "guardrailFailure",
+      "circuitViolation",
+      "redactionWarning"
+    ];
+  }
+});
+
+// packages/core/src/cohort/compare.ts
+function compareNumber(metric, label, baseline, candidate, higherIsWorse = true) {
+  if (baseline === void 0 && candidate === void 0) return void 0;
+  const delta = baseline !== void 0 && candidate !== void 0 ? candidate - baseline : void 0;
+  const regression = delta !== void 0 && (higherIsWorse && delta > 0 || !higherIsWorse && delta < 0);
+  return {
+    metric,
+    baseline,
+    candidate,
+    delta,
+    regression,
+    message: `${label}: baseline=${baseline ?? "n/a"} candidate=${candidate ?? "n/a"}${delta !== void 0 ? ` (delta ${delta})` : ""}`
+  };
+}
+function pickAggregate(groups, cohortLabel, groupKey) {
+  return groups.find(
+    (group) => group.cohortLabel === cohortLabel && (groupKey === void 0 || group.groupKey === groupKey)
+  );
+}
+function compareCohortAggregates(groups, options) {
+  const baselineAgg = pickAggregate(groups, options.baseline, options.groupKey);
+  const candidateAgg = pickAggregate(groups, options.candidate, options.groupKey);
+  const comparisons = [];
+  for (const metric of options.metrics) {
+    switch (metric) {
+      case "errorRate": {
+        const item = compareNumber(
+          metric,
+          "Error rate",
+          baselineAgg?.errorRate,
+          candidateAgg?.errorRate
+        );
+        if (item) comparisons.push(item);
+        break;
+      }
+      case "duration": {
+        const item = compareNumber(
+          metric,
+          "Average duration (ms)",
+          baselineAgg?.avgDurationMs,
+          candidateAgg?.avgDurationMs
+        );
+        if (item) comparisons.push(item);
+        break;
+      }
+      case "llmCallCount": {
+        const item = compareNumber(
+          metric,
+          "Average LLM calls",
+          baselineAgg?.avgLlmCallCount,
+          candidateAgg?.avgLlmCallCount
+        );
+        if (item) comparisons.push(item);
+        break;
+      }
+      case "tokenUsage": {
+        const item = compareNumber(
+          metric,
+          "Average token usage",
+          baselineAgg?.avgTokenUsage,
+          candidateAgg?.avgTokenUsage
+        );
+        if (item) comparisons.push(item);
+        break;
+      }
+      case "retryCount": {
+        const item = compareNumber(
+          metric,
+          "Average retries",
+          baselineAgg?.avgRetryCount,
+          candidateAgg?.avgRetryCount
+        );
+        if (item) comparisons.push(item);
+        break;
+      }
+      case "observationFailure": {
+        const item = compareNumber(
+          metric,
+          "Observation failure rate",
+          baselineAgg?.observationFailureRate,
+          candidateAgg?.observationFailureRate
+        );
+        if (item) comparisons.push(item);
+        break;
+      }
+      case "toolChoice": {
+        const baselineValue = baselineAgg?.dominantToolChoice;
+        const candidateValue = candidateAgg?.dominantToolChoice;
+        comparisons.push({
+          metric,
+          baseline: baselineValue,
+          candidate: candidateValue,
+          delta: baselineValue === candidateValue ? "same" : "changed",
+          regression: baselineValue !== candidateValue,
+          message: `Tool choice: baseline=${baselineValue ?? "n/a"} candidate=${candidateValue ?? "n/a"}`
+        });
+        break;
+      }
+      case "toolOrdering": {
+        const baselineValue = baselineAgg?.toolOrderingSignature;
+        const candidateValue = candidateAgg?.toolOrderingSignature;
+        comparisons.push({
+          metric,
+          baseline: baselineValue,
+          candidate: candidateValue,
+          delta: baselineValue === candidateValue ? "same" : "changed",
+          regression: baselineValue !== candidateValue,
+          message: `Tool ordering: baseline=${baselineValue ?? "n/a"} candidate=${candidateValue ?? "n/a"}`
+        });
+        break;
+      }
+      case "guardrailFailure": {
+        const item = compareNumber(
+          metric,
+          "Guardrail failures",
+          baselineAgg?.avgGuardrailFailures,
+          candidateAgg?.avgGuardrailFailures
+        );
+        if (item) comparisons.push(item);
+        break;
+      }
+      case "circuitViolation": {
+        const item = compareNumber(
+          metric,
+          "Circuit violations",
+          baselineAgg?.avgCircuitViolations,
+          candidateAgg?.avgCircuitViolations
+        );
+        if (item) comparisons.push(item);
+        break;
+      }
+      case "redactionWarning": {
+        const item = compareNumber(
+          metric,
+          "Redaction warnings",
+          baselineAgg?.avgRedactionWarnings,
+          candidateAgg?.avgRedactionWarnings
+        );
+        if (item) comparisons.push(item);
+        break;
+      }
+    }
+  }
+  return comparisons;
+}
+var init_compare = __esm({
+  "packages/core/src/cohort/compare.ts"() {
+  }
+});
+
+// packages/core/src/cohort/grouping.ts
+function parseCohortMetricList(value) {
+  if (value === void 0 || value.trim() === "") return [];
+  return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+}
+function parseGroupBySpec(groupBy) {
+  const raw = (groupBy ?? "model").trim();
+  if (raw === "model") return { kind: "model" };
+  if (raw === "session") return { kind: "session" };
+  if (raw === "group") return { kind: "group" };
+  if (raw.startsWith("metadata.")) {
+    const metadataKey = raw.slice("metadata.".length).trim();
+    if (metadataKey === "") throw new Error("metadata group-by requires a key.");
+    return { kind: "metadata", metadataKey };
+  }
+  throw new Error(`Unsupported --group-by value: ${raw}`);
+}
+function metadataString(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function resolveRunGroupKey(run, groupBy) {
+  const metadata = run.metadata ?? {};
+  switch (groupBy.kind) {
+    case "model":
+      return metadataString(metadata, "model") ?? "unknown";
+    case "session":
+      return extractSessionWorkflowMetadata(metadata)?.sessionId ?? metadataString(metadata, "sessionId") ?? "__unscoped__";
+    case "group":
+      return extractSessionWorkflowMetadata(metadata)?.groupId ?? metadataString(metadata, "groupId") ?? "__unscoped__";
+    case "metadata":
+      return metadataString(metadata, groupBy.metadataKey) ?? "__missing__";
+    default:
+      return "unknown";
+  }
+}
+function resolveCohortLabel(run, cohortKey, baseline, candidate) {
+  const label = metadataString(run.metadata, cohortKey);
+  if (label === void 0) return void 0;
+  if (baseline !== void 0 && label === baseline) return baseline;
+  if (candidate !== void 0 && label === candidate) return candidate;
+  if (baseline === void 0 && candidate === void 0) return label;
+  return void 0;
+}
+function filterRunsForCohort(runs, options) {
+  const warnings = [];
+  if (options.baseline === void 0 && options.candidate === void 0) {
+    return { runs: [...runs], warnings };
+  }
+  const selected = [];
+  for (const run of runs) {
+    const label = resolveCohortLabel(
+      run,
+      options.cohortKey,
+      options.baseline,
+      options.candidate
+    );
+    if (label !== void 0) selected.push(run);
+  }
+  if (selected.length === 0) {
+    warnings.push(
+      `No runs matched baseline/candidate labels on metadata.${options.cohortKey}.`
+    );
+  }
+  return { runs: selected, warnings };
+}
+var init_grouping = __esm({
+  "packages/core/src/cohort/grouping.ts"() {
+    init_metadata();
+  }
+});
+
+// packages/core/src/cohort/metrics.ts
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function toolSteps(events) {
+  const ordering = [];
+  const choices = /* @__PURE__ */ new Set();
+  const sorted = [...events].filter((event) => event.event === "step_started").sort((a, b) => a.timestamp - b.timestamp);
+  for (const event of sorted) {
+    const step = event;
+    if (step.type !== "tool") continue;
+    const name = typeof step.metadata?.toolName === "string" ? step.metadata.toolName : step.name;
+    ordering.push(name);
+    choices.add(name);
+  }
+  return { choices: [...choices].sort(), ordering };
+}
+async function computeCohortRunMetrics(input3) {
+  const events = await readTraceEventsFromFile(input3.filePath);
+  const summary = buildRunSummary(events);
+  const tools = toolSteps(events);
+  const outcomes = extractOutcomesFromTraceEvents(events);
+  const observationFailures = outcomes.filter((item) => item.status === "failed").length;
+  const metadata = input3.metadata ?? {};
+  const retryCount2 = asNumber(metadata.attempt) !== void 0 && asNumber(metadata.attempt) > 1 ? asNumber(metadata.attempt) - 1 : typeof metadata.retryOf === "string" ? 1 : 0;
+  return {
+    runId: input3.runId,
+    ...input3.cohortLabel !== void 0 ? { cohortLabel: input3.cohortLabel } : {},
+    groupKey: input3.groupKey,
+    status: summary.status,
+    error: summary.status === "error",
+    durationMs: summary.durationMs ?? input3.durationMs,
+    llmCallCount: summary.llmSteps,
+    tokenUsageTotal: summary.totalTokens?.total,
+    retryCount: retryCount2,
+    observationFailures,
+    guardrailFailures: asNumber(metadata.guardrailFailures) ?? 0,
+    circuitViolations: asNumber(metadata.circuitViolations) ?? 0,
+    redactionWarnings: asNumber(metadata.redactionWarnings) ?? 0,
+    toolChoices: tools.choices,
+    toolOrdering: tools.ordering
+  };
+}
+function percentile2(values, p) {
+  if (values.length === 0) return void 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.ceil(p / 100 * sorted.length) - 1)
+  );
+  return sorted[idx];
+}
+function dominantToolChoice(runs) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    const signature = run.toolChoices.join(",");
+    if (signature === "") continue;
+    counts.set(signature, (counts.get(signature) ?? 0) + 1);
+  }
+  let best;
+  let bestCount = 0;
+  for (const [key, count] of counts) {
+    if (count > bestCount) {
+      best = key;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+function orderingSignature(runs) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    const signature = run.toolOrdering.join(">");
+    if (signature === "") continue;
+    counts.set(signature, (counts.get(signature) ?? 0) + 1);
+  }
+  let best;
+  let bestCount = 0;
+  for (const [key, count] of counts) {
+    if (count > bestCount) {
+      best = key;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+function aggregateCohortMetrics(runs, groupKey, cohortLabel) {
+  const durations = runs.map((run) => run.durationMs).filter((value) => typeof value === "number");
+  const tokenValues = runs.map((run) => run.tokenUsageTotal).filter((value) => typeof value === "number");
+  const errors = runs.filter((run) => run.error).length;
+  const observationFailures = runs.reduce((sum, run) => sum + run.observationFailures, 0);
+  return {
+    groupKey,
+    ...cohortLabel !== void 0 ? { cohortLabel } : {},
+    runCount: runs.length,
+    errorRate: runs.length > 0 ? errors / runs.length : 0,
+    avgDurationMs: durations.length > 0 ? durations.reduce((sum, value) => sum + value, 0) / durations.length : void 0,
+    p95DurationMs: percentile2(durations, 95),
+    avgLlmCallCount: runs.length > 0 ? runs.reduce((sum, run) => sum + run.llmCallCount, 0) / runs.length : 0,
+    avgTokenUsage: tokenValues.length > 0 ? tokenValues.reduce((sum, value) => sum + value, 0) / tokenValues.length : void 0,
+    avgRetryCount: runs.length > 0 ? runs.reduce((sum, run) => sum + run.retryCount, 0) / runs.length : 0,
+    observationFailureRate: runs.length > 0 ? observationFailures / runs.length : 0,
+    avgGuardrailFailures: runs.length > 0 ? runs.reduce((sum, run) => sum + run.guardrailFailures, 0) / runs.length : 0,
+    avgCircuitViolations: runs.length > 0 ? runs.reduce((sum, run) => sum + run.circuitViolations, 0) / runs.length : 0,
+    avgRedactionWarnings: runs.length > 0 ? runs.reduce((sum, run) => sum + run.redactionWarnings, 0) / runs.length : 0,
+    dominantToolChoice: dominantToolChoice(runs),
+    toolOrderingSignature: orderingSignature(runs)
+  };
+}
+var init_metrics = __esm({
+  "packages/core/src/cohort/metrics.ts"() {
+    init_extract();
+    init_trace_metadata();
+    init_storage();
+  }
+});
+
+// packages/core/src/cohort/analyze.ts
+function normalizeMetrics(metrics) {
+  if (metrics === void 0 || metrics.length === 0) return [...DEFAULT_METRICS];
+  const allowed = new Set(COHORT_METRIC_IDS);
+  return metrics.filter((metric) => allowed.has(metric));
+}
+async function analyzeCohort(runsInput, options) {
+  const cohortKey = options.cohortKey ?? "cohort";
+  const groupBySpec = parseGroupBySpec(options.groupBy);
+  const metrics = normalizeMetrics(options.metrics);
+  const { runs: filteredRuns, warnings } = filterRunsForCohort(runsInput, {
+    cohortKey,
+    baseline: options.baseline,
+    candidate: options.candidate
+  });
+  const runMetrics = [];
+  for (const run of filteredRuns) {
+    if (run.filePath === void 0) continue;
+    const cohortLabel = resolveCohortLabel(
+      run,
+      cohortKey,
+      options.baseline,
+      options.candidate
+    );
+    runMetrics.push(
+      await computeCohortRunMetrics({
+        runId: run.runId,
+        filePath: run.filePath,
+        metadata: run.metadata,
+        status: run.status,
+        durationMs: run.durationMs,
+        groupKey: resolveRunGroupKey(run, groupBySpec),
+        cohortLabel
+      })
+    );
+  }
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const run of runMetrics) {
+    const key = `${run.cohortLabel ?? "*"}::${run.groupKey}`;
+    const bucket = groupMap.get(key) ?? [];
+    bucket.push(run);
+    groupMap.set(key, bucket);
+  }
+  const groups = [...groupMap.entries()].sort(([a], [b]) => a.localeCompare(b)).map(
+    ([, bucket]) => aggregateCohortMetrics(
+      bucket,
+      bucket[0].groupKey,
+      bucket[0]?.cohortLabel
+    )
+  );
+  const comparisons = options.baseline !== void 0 && options.candidate !== void 0 ? (() => {
+    const groupKeys = [
+      ...new Set(groups.map((group) => group.groupKey))
+    ].sort((a, b) => a.localeCompare(b));
+    const items = [];
+    for (const groupKey of groupKeys) {
+      items.push(
+        ...compareCohortAggregates(groups, {
+          baseline: options.baseline,
+          candidate: options.candidate,
+          metrics,
+          groupKey
+        })
+      );
+    }
+    return items;
+  })() : [];
+  const regression = comparisons.some((item) => item.regression);
+  return {
+    ok: !regression,
+    traceDir: options.traceDir,
+    ...options.baseline !== void 0 ? { baseline: options.baseline } : {},
+    ...options.candidate !== void 0 ? { candidate: options.candidate } : {},
+    cohortKey,
+    groupBy: options.groupBy ?? "model",
+    metrics,
+    groups,
+    comparisons,
+    runs: runMetrics,
+    warnings
+  };
+}
+var DEFAULT_METRICS;
+var init_analyze = __esm({
+  "packages/core/src/cohort/analyze.ts"() {
+    init_compare();
+    init_grouping();
+    init_metrics();
+    init_types5();
+    DEFAULT_METRICS = [
+      "errorRate",
+      "duration",
+      "toolChoice",
+      "observationFailure"
+    ];
+  }
+});
+
+// packages/core/src/exporters/helpers.ts
+function shouldRedactKey(key) {
+  const k = key.toLowerCase();
+  for (const s of REDACT_SUBSTRINGS) {
+    if (k.includes(s)) return true;
+  }
+  return false;
+}
+function safeString(value, maxLength) {
+  if (value === null || value === void 0) return "";
+  let s;
+  if (typeof value === "string") s = value;
+  else if (typeof value === "number" || typeof value === "boolean") s = String(value);
+  else s = stableJson(value, false);
+  if (maxLength !== void 0 && maxLength >= 0 && s.length > maxLength) {
+    return `${s.slice(0, maxLength)}\u2026`;
+  }
+  return s;
+}
+function escapeMarkdown(value) {
+  return value.replace(/\|/g, "\\|").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, " ");
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sortKeysDeep(input3) {
+  if (input3 === null || typeof input3 !== "object") return input3;
+  if (Array.isArray(input3)) return input3.map(sortKeysDeep);
+  const o = input3;
+  const out = {};
+  for (const k of Object.keys(o).sort()) {
+    out[k] = sortKeysDeep(o[k]);
+  }
+  return out;
+}
+function stableJson(value, pretty) {
+  const sorted = sortKeysDeep(value);
+  return pretty === true ? JSON.stringify(sorted, null, 2) : JSON.stringify(sorted);
+}
+function compactAttributes3(attrs, options) {
+  if (attrs === void 0) return {};
+  const maxLen = options?.maxLength ?? 500;
+  const redacted = options?.redacted ?? true;
+  const out = {};
+  for (const key of Object.keys(attrs).sort()) {
+    if (redacted && shouldRedactKey(key)) {
+      out[key] = "[REDACTED]";
+      continue;
+    }
+    const v = attrs[key];
+    out[key] = compactValue(v, maxLen, redacted);
+  }
+  return out;
+}
+function compactValue(value, maxLen, redacted) {
+  if (value === null || typeof value !== "object") {
+    return typeof value === "string" ? safeString(value, maxLen) : value;
+  }
+  if (Array.isArray(value)) {
+    const arr = value.slice(0, 20).map((x) => compactValue(x, maxLen, redacted));
+    if (value.length > 20) arr.push(`\u2026(+${value.length - 20} more)`);
+    return arr;
+  }
+  const o = value;
+  const inner = {};
+  for (const k of Object.keys(o)) {
+    if (redacted && shouldRedactKey(k)) inner[k] = "[REDACTED]";
+    else inner[k] = compactValue(o[k], maxLen, redacted);
+  }
+  return inner;
+}
+function flattenTree(tree) {
+  const out = [];
+  function walk(nodes) {
+    for (const n of nodes) {
+      out.push(n);
+      if (n.children.length > 0) walk(n.children);
+    }
+  }
+  walk(tree.children);
+  return out;
+}
+function zeroKinds() {
+  return {
+    RUN: 0,
+    AGENT: 0,
+    LLM: 0,
+    TOOL: 0,
+    CHAIN: 0,
+    RETRIEVER: 0,
+    DECISION: 0,
+    RESULT: 0,
+    ERROR: 0,
+    LOGIC: 0,
+    LOG: 0,
+    OUTCOME: 0
+  };
+}
+var REDACT_SUBSTRINGS;
+var init_helpers = __esm({
+  "packages/core/src/exporters/helpers.ts"() {
+    REDACT_SUBSTRINGS = [
+      "authorization",
+      "cookie",
+      "token",
+      "apikey",
+      "password",
+      "secret",
+      "email"
+    ];
+  }
+});
+
+// packages/core/src/cohort/render.ts
+function formatRate(value) {
+  if (value === void 0) return "n/a";
+  return `${(value * 100).toFixed(1)}%`;
+}
+function renderCohortSummaryMarkdown(result) {
+  const lines = [];
+  lines.push("# Cohort analysis");
+  lines.push("");
+  lines.push(`Trace directory: \`${result.traceDir}\``);
+  lines.push(`Group by: \`${result.groupBy}\``);
+  if (result.baseline !== void 0 && result.candidate !== void 0) {
+    lines.push(
+      `Baseline/Candidate key: \`${result.cohortKey}\` (${result.baseline} vs ${result.candidate})`
+    );
+  }
+  lines.push(`Status: **${result.ok ? "PASS" : "REGRESSION"}**`);
+  lines.push("");
+  if (result.warnings.length > 0) {
+    lines.push("## Warnings");
+    for (const warning of result.warnings) lines.push(`- ${warning}`);
+    lines.push("");
+  }
+  lines.push("## Groups");
+  for (const group of result.groups) {
+    lines.push(
+      `### ${group.cohortLabel ?? "all"} / ${group.groupKey} (${group.runCount} runs)`
+    );
+    lines.push(`- Error rate: ${formatRate(group.errorRate)}`);
+    if (group.avgDurationMs !== void 0) {
+      lines.push(`- Avg duration: ${Math.round(group.avgDurationMs)} ms`);
+    }
+    if (group.dominantToolChoice !== void 0) {
+      lines.push(`- Dominant tools: ${group.dominantToolChoice}`);
+    }
+    lines.push(
+      `- Observation failure rate: ${formatRate(group.observationFailureRate)}`
+    );
+    lines.push("");
+  }
+  if (result.comparisons.length > 0) {
+    lines.push("## Comparisons");
+    for (const comparison of result.comparisons) {
+      const flag = comparison.regression ? " **REGRESSION**" : "";
+      lines.push(`- ${comparison.message}${flag}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function renderCohortReportHtml(result) {
+  const rows = result.groups.map(
+    (group) => `<tr><td>${escapeHtml(group.cohortLabel ?? "all")}</td><td>${escapeHtml(group.groupKey)}</td><td>${group.runCount}</td><td>${escapeHtml(formatRate(group.errorRate))}</td><td>${group.avgDurationMs !== void 0 ? Math.round(group.avgDurationMs) : "n/a"}</td></tr>`
+  ).join("");
+  const comparisons = result.comparisons.map(
+    (item) => `<li>${escapeHtml(item.message)}${item.regression ? " <strong>REGRESSION</strong>" : ""}</li>`
+  ).join("");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>Cohort report</title>
+  <style>
+    body { font-family: system-ui, sans-serif; margin: 2rem; }
+    table { border-collapse: collapse; width: 100%; }
+    th, td { border: 1px solid #ddd; padding: 0.5rem; text-align: left; }
+    th { background: #f6f6f6; }
+  </style>
+</head>
+<body>
+  <h1>Cohort analysis</h1>
+  <p>Status: <strong>${result.ok ? "PASS" : "REGRESSION"}</strong></p>
+  <p>Trace directory: <code>${escapeHtml(result.traceDir)}</code></p>
+  <h2>Groups</h2>
+  <table>
+    <thead><tr><th>Cohort</th><th>Group</th><th>Runs</th><th>Error rate</th><th>Avg duration (ms)</th></tr></thead>
+    <tbody>${rows}</tbody>
+  </table>
+  ${result.comparisons.length > 0 ? `<h2>Comparisons</h2><ul>${comparisons}</ul>` : ""}
+</body>
+</html>`;
+}
+function renderCohortReport(result, options = {}) {
+  const format = options.format ?? "markdown";
+  if (format === "json") return JSON.stringify(result, null, 2);
+  if (format === "html") return renderCohortReportHtml(result);
+  return renderCohortSummaryMarkdown(result);
+}
+var init_render2 = __esm({
+  "packages/core/src/cohort/render.ts"() {
+    init_helpers();
+  }
+});
+
+// packages/core/src/cohort/index.ts
+var init_cohort2 = __esm({
+  "packages/core/src/cohort/index.ts"() {
+    init_types5();
+    init_analyze();
+    init_compare();
+    init_grouping();
+    init_metrics();
+    init_render2();
+  }
+});
+
 // packages/core/src/inspect-run.ts
 var init_inspect_run = __esm({
   "packages/core/src/inspect-run.ts"() {
@@ -8320,13 +8996,14 @@ var init_advanced = __esm({
     init_duration();
     init_bundle();
     init_suite();
+    init_cohort2();
     init_maybe_inspect_run();
   }
 });
 
 // packages/index-sqlite/src/types.ts
 var INDEX_SCHEMA_VERSION, INDEX_DB_FILENAME;
-var init_types5 = __esm({
+var init_types6 = __esm({
   "packages/index-sqlite/src/types.ts"() {
     INDEX_SCHEMA_VERSION = "1";
     INDEX_DB_FILENAME = "trace-index.sqlite";
@@ -8384,19 +9061,19 @@ var require_file_uri_to_path = __commonJS({
       var rest = decodeURI(uri.substring(7));
       var firstSlash = rest.indexOf("/");
       var host = rest.substring(0, firstSlash);
-      var path30 = rest.substring(firstSlash + 1);
+      var path31 = rest.substring(firstSlash + 1);
       if ("localhost" == host) host = "";
       if (host) {
         host = sep + sep + host;
       }
-      path30 = path30.replace(/^(.+)\|/, "$1:");
+      path31 = path31.replace(/^(.+)\|/, "$1:");
       if (sep == "\\") {
-        path30 = path30.replace(/\//g, "\\");
+        path31 = path31.replace(/\//g, "\\");
       }
-      if (/^.+\:/.test(path30)) ; else {
-        path30 = sep + path30;
+      if (/^.+\:/.test(path31)) ; else {
+        path31 = sep + path31;
       }
-      return host + path30;
+      return host + path31;
     }
   }
 });
@@ -8405,18 +9082,18 @@ var require_file_uri_to_path = __commonJS({
 var require_bindings = __commonJS({
   "node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js"(exports$1, module) {
     var fs = __require("fs");
-    var path30 = __require("path");
+    var path31 = __require("path");
     var fileURLToPath2 = require_file_uri_to_path();
-    var join = path30.join;
-    var dirname = path30.dirname;
-    var exists2 = fs.accessSync && function(path31) {
+    var join = path31.join;
+    var dirname = path31.dirname;
+    var exists2 = fs.accessSync && function(path32) {
       try {
-        fs.accessSync(path31);
+        fs.accessSync(path32);
       } catch (e) {
         return false;
       }
       return true;
-    } || fs.existsSync || path30.existsSync;
+    } || fs.existsSync || path31.existsSync;
     var defaults = {
       arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
       compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
@@ -8461,7 +9138,7 @@ var require_bindings = __commonJS({
       if (!opts.module_root) {
         opts.module_root = exports$1.getRoot(exports$1.getFileName());
       }
-      if (path30.extname(opts.bindings) != ".node") {
+      if (path31.extname(opts.bindings) != ".node") {
         opts.bindings += ".node";
       }
       var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
@@ -8696,7 +9373,7 @@ var require_pragma = __commonJS({
 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 path30 = __require("path");
+    var path31 = __require("path");
     var { promisify } = __require("util");
     var { cppdb } = require_util();
     var fsAccess = promisify(fs.access);
@@ -8712,7 +9389,7 @@ var require_backup = __commonJS({
       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(path30.dirname(filename)).catch(() => {
+      await fsAccess(path31.dirname(filename)).catch(() => {
         throw new TypeError("Cannot save backup because the directory does not exist");
       });
       const isNewFile = await fsAccess(filename).then(() => false, () => true);
@@ -9012,7 +9689,7 @@ var require_inspect = __commonJS({
 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 path30 = __require("path");
+    var path31 = __require("path");
     var util = require_util();
     var SqliteError = require_sqlite_error();
     var DEFAULT_ADDON;
@@ -9048,7 +9725,7 @@ var require_database = __commonJS({
         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(path30.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+        addon = requireFunc(path31.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
       } else {
         addon = nativeBinding;
       }
@@ -9056,7 +9733,7 @@ var require_database = __commonJS({
         addon.setErrorConstructor(SqliteError);
         addon.isInitialized = true;
       }
-      if (!anonymous && !fs.existsSync(path30.dirname(filename))) {
+      if (!anonymous && !fs.existsSync(path31.dirname(filename))) {
         throw new TypeError("Cannot open database because the directory does not exist");
       }
       Object.defineProperties(this, {
@@ -9104,7 +9781,7 @@ function metaDefaults(sourceDir, fileCount) {
 var INDEX_SCHEMA_SQL, DERIVE_SESSIONS_SQL, META_KEYS;
 var init_schema = __esm({
   "packages/index-sqlite/src/schema.ts"() {
-    init_types5();
+    init_types6();
     INDEX_SCHEMA_SQL = `
 DROP TABLE IF EXISTS meta;
 DROP TABLE IF EXISTS errors;
@@ -9357,7 +10034,7 @@ var init_builder = __esm({
     import_better_sqlite3 = __toESM(require_lib());
     init_advanced();
     init_schema();
-    init_types5();
+    init_types6();
     DEFAULT_MAX_RUNS = 1e4;
     rebuildIndex = buildIndex;
   }
@@ -9507,14 +10184,14 @@ __export(src_exports, {
 });
 var init_src = __esm({
   "packages/index-sqlite/src/index.ts"() {
-    init_types5();
+    init_types6();
     init_builder();
     init_query();
   }
 });
 
 // package.json
-var version = "5.0.0";
+var version = "5.1.0";
 
 // packages/cli/src/list.ts
 init_advanced();
@@ -10459,7 +11136,7 @@ init_nanoid();
 function isFiniteNumber2(v) {
   return typeof v === "number" && Number.isFinite(v);
 }
-function safeString(v) {
+function safeString2(v) {
   if (typeof v !== "string") return void 0;
   const t = v.trim();
   return t === "" ? void 0 : t;
@@ -10509,7 +11186,7 @@ var EventNormalizer = class {
     let runId;
     for (const k of cfg.runIdKeys) {
       const v = raw[k];
-      const s = safeString(v);
+      const s = safeString2(v);
       if (s) {
         runId = s;
         break;
@@ -10525,7 +11202,7 @@ var EventNormalizer = class {
         }
       };
     }
-    const eventName = safeString(raw[cfg.eventKey]);
+    const eventName = safeString2(raw[cfg.eventKey]);
     if (!eventName) {
       return {
         warning: {
@@ -10543,7 +11220,7 @@ var EventNormalizer = class {
     const timestamp = parsedTs ?? Date.now();
     const timestampMissing = parsedTs === void 0;
     const parentIdKey = cfg.parentIdKey;
-    const parentId = parentIdKey ? safeString(raw[parentIdKey]) : void 0;
+    const parentId = parentIdKey ? safeString2(raw[parentIdKey]) : void 0;
     let durationMs2;
     const durationKey = cfg.durationKey;
     if (durationKey) {
@@ -10554,7 +11231,7 @@ var EventNormalizer = class {
     }
     let status;
     const statusKey = cfg.statusKey;
-    const statusRaw = statusKey ? safeString(raw[statusKey]) : void 0;
+    const statusRaw = statusKey ? safeString2(raw[statusKey]) : void 0;
     if (statusRaw === "running" || statusRaw === "ok" || statusRaw === "error") {
       status = statusRaw;
     } else if (mapping?.status) {
@@ -11498,115 +12175,8 @@ function redactRunTreeForExport(tree, options) {
   return clone;
 }
 
-// packages/core/src/exporters/helpers.ts
-var REDACT_SUBSTRINGS = [
-  "authorization",
-  "cookie",
-  "token",
-  "apikey",
-  "password",
-  "secret",
-  "email"
-];
-function shouldRedactKey(key) {
-  const k = key.toLowerCase();
-  for (const s of REDACT_SUBSTRINGS) {
-    if (k.includes(s)) return true;
-  }
-  return false;
-}
-function safeString2(value, maxLength) {
-  if (value === null || value === void 0) return "";
-  let s;
-  if (typeof value === "string") s = value;
-  else if (typeof value === "number" || typeof value === "boolean") s = String(value);
-  else s = stableJson(value, false);
-  if (maxLength !== void 0 && maxLength >= 0 && s.length > maxLength) {
-    return `${s.slice(0, maxLength)}\u2026`;
-  }
-  return s;
-}
-function escapeMarkdown(value) {
-  return value.replace(/\|/g, "\\|").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, " ");
-}
-function escapeHtml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-function sortKeysDeep(input3) {
-  if (input3 === null || typeof input3 !== "object") return input3;
-  if (Array.isArray(input3)) return input3.map(sortKeysDeep);
-  const o = input3;
-  const out = {};
-  for (const k of Object.keys(o).sort()) {
-    out[k] = sortKeysDeep(o[k]);
-  }
-  return out;
-}
-function stableJson(value, pretty) {
-  const sorted = sortKeysDeep(value);
-  return pretty === true ? JSON.stringify(sorted, null, 2) : JSON.stringify(sorted);
-}
-function compactAttributes3(attrs, options) {
-  if (attrs === void 0) return {};
-  const maxLen = options?.maxLength ?? 500;
-  const redacted = options?.redacted ?? true;
-  const out = {};
-  for (const key of Object.keys(attrs).sort()) {
-    if (redacted && shouldRedactKey(key)) {
-      out[key] = "[REDACTED]";
-      continue;
-    }
-    const v = attrs[key];
-    out[key] = compactValue(v, maxLen, redacted);
-  }
-  return out;
-}
-function compactValue(value, maxLen, redacted) {
-  if (value === null || typeof value !== "object") {
-    return typeof value === "string" ? safeString2(value, maxLen) : value;
-  }
-  if (Array.isArray(value)) {
-    const arr = value.slice(0, 20).map((x) => compactValue(x, maxLen, redacted));
-    if (value.length > 20) arr.push(`\u2026(+${value.length - 20} more)`);
-    return arr;
-  }
-  const o = value;
-  const inner = {};
-  for (const k of Object.keys(o)) {
-    if (redacted && shouldRedactKey(k)) inner[k] = "[REDACTED]";
-    else inner[k] = compactValue(o[k], maxLen, redacted);
-  }
-  return inner;
-}
-function flattenTree(tree) {
-  const out = [];
-  function walk(nodes) {
-    for (const n of nodes) {
-      out.push(n);
-      if (n.children.length > 0) walk(n.children);
-    }
-  }
-  walk(tree.children);
-  return out;
-}
-function zeroKinds() {
-  return {
-    RUN: 0,
-    AGENT: 0,
-    LLM: 0,
-    TOOL: 0,
-    CHAIN: 0,
-    RETRIEVER: 0,
-    DECISION: 0,
-    RESULT: 0,
-    ERROR: 0,
-    LOGIC: 0,
-    LOG: 0,
-    OUTCOME: 0
-  };
-}
-
 // packages/core/src/exporters/html-exporter.ts
+init_helpers();
 function renderTreeHtml(nodes, ulClass = "tree") {
   if (nodes.length === 0) return "";
   const parts = [`<ul class="${ulClass}">`];
@@ -11679,7 +12249,7 @@ function exportHtml(tree, options) {
   if (includeErrors && errors.length > 0) {
     errorsHtml += "<h2>Errors</h2><ul>";
     for (const n of errors) {
-      const msg = n.event.attributes && typeof n.event.attributes.error === "object" ? safeString2(
+      const msg = n.event.attributes && typeof n.event.attributes.error === "object" ? safeString(
         n.event.attributes.error.message,
         maxLen
       ) : "";
@@ -11744,6 +12314,7 @@ ${attrsHtml}
 }
 
 // packages/core/src/exporters/markdown-exporter.ts
+init_helpers();
 function renderTreeAscii(nodes, indent = "") {
   const lines = [];
   for (let i = 0; i < nodes.length; i++) {
@@ -11828,7 +12399,7 @@ function exportMarkdown(tree, options) {
     lines.push("## Errors");
     lines.push("");
     for (const n of errors) {
-      const msg = n.event.attributes && typeof n.event.attributes.error === "object" ? safeString2(
+      const msg = n.event.attributes && typeof n.event.attributes.error === "object" ? safeString(
         n.event.attributes.error.message,
         maxLen
       ) : "";
@@ -11866,6 +12437,7 @@ function exportMarkdown(tree, options) {
     warnings
   };
 }
+init_helpers();
 function hexFrom(seed, byteLen) {
   return crypto__default.default.createHash("sha256").update(seed, "utf8").digest("hex").slice(0, byteLen * 2);
 }
@@ -11992,6 +12564,9 @@ function exportOpenInference(tree, options) {
     warnings
   };
 }
+
+// packages/core/src/exporters/otlp-json-exporter.ts
+init_helpers();
 function hexFrom2(seed, byteLen) {
   return crypto__default.default.createHash("sha256").update(seed, "utf8").digest("hex").slice(0, byteLen * 2);
 }
@@ -12195,7 +12770,11 @@ function validateExportContent(format, content) {
   return { ok: false, format, errors, warnings };
 }
 
+// packages/core/src/exporters/index.ts
+init_helpers();
+
 // packages/core/src/exporters/manual-trace-adapter.ts
+init_helpers();
 function stepTypeToInspectKind(t) {
   switch (t) {
     case "llm":
@@ -12375,6 +12954,7 @@ function validateExport(result) {
 }
 
 // packages/core/src/report.ts
+init_helpers();
 init_timeline();
 init_what();
 init_outcomes();
@@ -12531,6 +13111,9 @@ ${attrsSection}
   };
 }
 
+// packages/core/src/entries/exporters.ts
+init_helpers();
+
 // packages/cli/src/export.ts
 function parseRedactionProfile(s) {
   const v = (s ?? "local").trim().toLowerCase();
@@ -12752,6 +13335,7 @@ function manualTraceEventsToComparableRun(events) {
 }
 
 // packages/core/src/diff/engine.ts
+init_helpers();
 var DEFAULT_THRESHOLD_MS = 0;
 function pathSeg(step, index) {
   return { index, name: step.name, stepId: step.id };
@@ -12791,13 +13375,13 @@ function pairSteps(left, right) {
   return pairs;
 }
 function compareLeafSteps(L, R, segments, opts, out) {
-  const path30 = buildPath(segments);
+  const path31 = buildPath(segments);
   if (L.name !== R.name) {
     out.push({
       kind: "structure",
       severity: "warning",
       message: "Step name differs",
-      path: path30,
+      path: path31,
       left: L.name,
       right: R.name
     });
@@ -12807,7 +13391,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-type",
       severity: "warning",
       message: "Step type differs",
-      path: path30,
+      path: path31,
       left: L.type,
       right: R.type
     });
@@ -12817,7 +13401,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-status",
       severity: "warning",
       message: "Step status differs",
-      path: path30,
+      path: path31,
       left: L.status,
       right: R.status
     });
@@ -12829,7 +13413,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "error",
       severity: "error",
       message: "Step error message differs",
-      path: path30,
+      path: path31,
       left: le || void 0,
       right: re || void 0
     });
@@ -12847,7 +13431,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
         kind: "duration",
         severity: "info",
         message: "Step duration differs",
-        path: path30,
+        path: path31,
         left: ld,
         right: rd
       });
@@ -12860,7 +13444,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "metadata",
       severity: "info",
       message: "Step metadata differs",
-      path: path30,
+      path: path31,
       left: L.metadata,
       right: R.metadata
     });
@@ -12872,7 +13456,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "output",
       severity: "info",
       message: "Output preview differs",
-      path: path30,
+      path: path31,
       left: L.outputPreview,
       right: R.outputPreview
     });
@@ -13033,11 +13617,11 @@ function diffRuns(left, right, options) {
 
 // packages/core/src/diff/renderer.ts
 init_source();
-function formatPath(path30) {
-  if (path30 === void 0 || path30.path.length === 0) {
+function formatPath(path31) {
+  if (path31 === void 0 || path31.path.length === 0) {
     return "(run)";
   }
-  return path30.path.map((s) => s.name).join(" > ");
+  return path31.path.map((s) => s.name).join(" > ");
 }
 function formatValue(v, verbose) {
   if (v === void 0) return "(undefined)";
@@ -14158,17 +14742,17 @@ function applyRule(rule, value, replacement) {
   }
   return value;
 }
-function childPath(path30, key) {
+function childPath(path31, key) {
   if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) {
-    return path30 ? `${path30}.${key}` : key;
+    return path31 ? `${path31}.${key}` : key;
   }
-  return `${path30 || "$"}[${JSON.stringify(key)}]`;
+  return `${path31 || "$"}[${JSON.stringify(key)}]`;
 }
-function indexPath(path30, index) {
-  return `${path30 || "$"}[${index}]`;
+function indexPath(path31, index) {
+  return `${path31 || "$"}[${index}]`;
 }
-function makeFinding(path30, detector, action, matchKind, severity = "warning", preview) {
-  return preview === void 0 ? { path: path30, detector, action, severity, matchKind } : { path: path30, detector, action, severity, matchKind, preview };
+function makeFinding(path31, detector, action, matchKind, severity = "warning", preview) {
+  return preview === void 0 ? { path: path31, detector, action, severity, matchKind } : { path: path31, detector, action, severity, matchKind, preview };
 }
 function createRedactionProfile(profile = "local") {
   switch (profile) {
@@ -14237,11 +14821,11 @@ var Redactor2 = class {
   #recordFinding(state, finding) {
     if (this.#collectFindings) state.findings.push(finding);
   }
-  #redactValue(value, key, path30, depth, state) {
+  #redactValue(value, key, path31, depth, state) {
     if (depth > this.#maxDepth) {
       this.#recordFinding(
         state,
-        makeFinding(path30, "structure.maxDepth", "truncate", "value", "warning")
+        makeFinding(path31, "structure.maxDepth", "truncate", "value", "warning")
       );
       return "[Truncated]";
     }
@@ -14250,19 +14834,19 @@ var Redactor2 = class {
       if (rule) {
         this.#recordFinding(
           state,
-          makeFinding(path30, `key.${rule.key}`, actionForRule(rule), "key", "warning")
+          makeFinding(path31, `key.${rule.key}`, actionForRule(rule), "key", "warning")
         );
         return applyRule(rule, value, this.#replacement);
       }
     }
     for (const detector of this.#detectors) {
-      const detections = detector.detect({ path: path30, key, value });
+      const detections = detector.detect({ path: path31, key, value });
       for (const detection of detections) {
         const action = detection.action ?? "replace";
         this.#recordFinding(
           state,
           makeFinding(
-            path30,
+            path31,
             detector.id,
             action,
             detection.matchKind ?? detector.matchKind ?? "custom",
@@ -14280,7 +14864,7 @@ var Redactor2 = class {
       const out = [];
       state.seen.set(value, out);
       value.forEach((item, index) => {
-        out[index] = this.#redactValue(item, void 0, indexPath(path30, index), depth + 1, state);
+        out[index] = this.#redactValue(item, void 0, indexPath(path31, index), depth + 1, state);
       });
       return out;
     }
@@ -14292,7 +14876,7 @@ var Redactor2 = class {
         out[entryKey] = this.#redactValue(
           entryValue,
           entryKey,
-          childPath(path30 === "$" ? "" : path30, entryKey),
+          childPath(path31 === "$" ? "" : path31, entryKey),
           depth + 1,
           state
         );
@@ -15233,23 +15817,23 @@ function evaluatePromptInjection(text, options = {}) {
   }
   return fail(ruleId, `Matched ${evidence.length} injection pattern(s).`, evidence, "warning");
 }
-function validateSchemaField(value, field, path30, evidence) {
+function validateSchemaField(value, field, path31, 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: path30, preview: `expected ${field.type}, got ${actual}` });
+      evidence.push({ ruleId, path: path31, preview: `expected ${field.type}, got ${actual}` });
       return;
     }
   }
   if (field.enum && !field.enum.some((item) => Object.is(item, value))) {
-    evidence.push({ ruleId, path: path30, preview: "value not in enum" });
+    evidence.push({ ruleId, path: path31, 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: `${path30}.${key}`, preview: "missing required key" });
+        evidence.push({ ruleId, path: `${path31}.${key}`, preview: "missing required key" });
       }
     }
   }
@@ -15750,10 +16334,10 @@ function printHuman(result) {
     console.log(`- ${diagnostic7.code}: ${diagnostic7.message}`);
   }
   for (const finding of result.findings) {
-    const path30 = finding.evidence[0]?.path;
+    const path31 = finding.evidence[0]?.path;
     const run = finding.evidence[0]?.runId;
     const runPrefix = run ? `[${run}] ` : "";
-    console.log(`- ${runPrefix}${finding.ruleId}: ${finding.message}${path30 ? ` (${path30})` : ""}`);
+    console.log(`- ${runPrefix}${finding.ruleId}: ${finding.message}${path31 ? ` (${path31})` : ""}`);
   }
 }
 function readErrorResult(error) {
@@ -16294,10 +16878,10 @@ async function evalRun(input3, options = {}) {
     diagnostics: []
   };
 }
-function evidenceForRun(run, path30) {
-  return [{ runId: run.runId, ...path30 !== void 0 ? { path: path30 } : {} }];
+function evidenceForRun(run, path31) {
+  return [{ runId: run.runId, ...path31 !== void 0 ? { path: path31 } : {} }];
 }
-function evidenceForEvent(event, path30) {
+function evidenceForEvent(event, path31) {
   return [
     {
       runId: event.runId,
@@ -16305,7 +16889,7 @@ function evidenceForEvent(event, path30) {
       ...event.parentId !== void 0 ? { parentId: event.parentId } : {},
       kind: event.kind,
       name: event.name,
-      ...path30 !== void 0 ? { path: path30 } : {}
+      ...path31 !== void 0 ? { path: path31 } : {}
     }
   ];
 }
@@ -16463,9 +17047,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, path30) {
+function firstEvidence(fields, run, path31) {
   const first = fields[0];
-  return first === void 0 ? evidenceForRun(run, path30) : evidenceForEvent(first.node.event, first.path);
+  return first === void 0 ? evidenceForRun(run, path31) : evidenceForEvent(first.node.event, first.path);
 }
 function collectSourceIds(nodes, keys) {
   const wanted = keySet(keys);
@@ -16842,8 +17426,8 @@ function renderEvalMarkdown(result) {
   if (result.findings.length > 0) {
     lines.push("", "## Findings");
     for (const finding of result.findings) {
-      const path30 = finding.evidence[0]?.path;
-      lines.push(`- ${finding.ruleId}: ${finding.message}${path30 ? ` (${path30})` : ""}`);
+      const path31 = finding.evidence[0]?.path;
+      lines.push(`- ${finding.ruleId}: ${finding.message}${path31 ? ` (${path31})` : ""}`);
     }
   }
   return `${lines.join("\n")}
@@ -17036,8 +17620,8 @@ function printHuman2(result) {
     console.log(`- ${diagnostic7.code}: ${diagnostic7.message}`);
   }
   for (const finding of result.findings) {
-    const path30 = finding.evidence[0]?.path;
-    console.log(`- ${finding.ruleId}: ${finding.message}${path30 ? ` (${path30})` : ""}`);
+    const path31 = finding.evidence[0]?.path;
+    console.log(`- ${finding.ruleId}: ${finding.message}${path31 ? ` (${path31})` : ""}`);
   }
 }
 function readErrorResult2(error) {
@@ -17275,8 +17859,8 @@ function printHuman3(result) {
     console.log(`- ${diagnostic7.code}: ${diagnostic7.message}`);
   }
   for (const finding of result.findings) {
-    const path30 = finding.evidence[0]?.path;
-    console.log(`- ${finding.ruleId}: ${finding.message}${path30 ? ` (${path30})` : ""}`);
+    const path31 = finding.evidence[0]?.path;
+    console.log(`- ${finding.ruleId}: ${finding.message}${path31 ? ` (${path31})` : ""}`);
   }
   console.log(`Note: ${result.note}`);
 }
@@ -17427,8 +18011,8 @@ function renderCheckSection(result) {
     `Diagnostics: ${result.diagnostics.length}`
   ];
   for (const finding of result.findings.slice(0, 10)) {
-    const path30 = finding.evidence[0]?.path ?? "(run)";
-    lines.push(`- ${finding.ruleId}: ${finding.message} (${path30})`);
+    const path31 = finding.evidence[0]?.path ?? "(run)";
+    lines.push(`- ${finding.ruleId}: ${finding.message} (${path31})`);
   }
   for (const diagnostic7 of result.diagnostics.slice(0, 10)) {
     lines.push(`- ${diagnostic7.code}: ${diagnostic7.message}`);
@@ -19878,6 +20462,88 @@ async function suiteReportCommand(options = {}) {
   }
 }
 
+// packages/cli/src/cohort.ts
+init_advanced();
+function normalizeMetrics2(raw) {
+  const parsed = parseCohortMetricList(raw);
+  if (parsed.length === 0) return void 0;
+  const allowed = new Set(COHORT_METRIC_IDS);
+  return parsed.filter(
+    (item) => allowed.has(item)
+  );
+}
+async function writeArtifacts(result, outputDir) {
+  await promises.mkdir(outputDir, { recursive: true });
+  const jsonPath = path23__default.default.join(outputDir, "cohort-results.json");
+  const markdownPath = path23__default.default.join(outputDir, "cohort-summary.md");
+  const htmlPath = path23__default.default.join(outputDir, "cohort-report.html");
+  await promises.writeFile(jsonPath, `${renderCohortReport(result, { format: "json" })}
+`, "utf-8");
+  await promises.writeFile(
+    markdownPath,
+    `${renderCohortReport(result, { format: "markdown" })}
+`,
+    "utf-8"
+  );
+  await promises.writeFile(htmlPath, `${renderCohortReport(result, { format: "html" })}
+`, "utf-8");
+  return { jsonPath, markdownPath, htmlPath };
+}
+async function cohortCommand(options = {}) {
+  try {
+    const traceDir = resolveTraceDir({ dir: options.dir });
+    const { runs } = await loadSessionRuns(traceDir);
+    const result = await analyzeCohort(runs, {
+      traceDir,
+      baseline: options.baseline,
+      candidate: options.candidate,
+      cohortKey: options.cohortKey,
+      groupBy: options.groupBy,
+      metrics: normalizeMetrics2(options.metric)
+    });
+    const format = options.format ?? (options.json ? "json" : "markdown");
+    let artifacts;
+    if (options.output !== void 0 && options.output.trim() !== "") {
+      artifacts = await writeArtifacts(result, path23__default.default.resolve(options.output.trim()));
+    }
+    if (options.json || format === "json") {
+      console.log(
+        JSON.stringify(
+          {
+            ...result,
+            artifacts: artifacts ?? null
+          },
+          null,
+          2
+        )
+      );
+    } else if (format === "html") {
+      console.log(renderCohortReport(result, { format: "html" }));
+      if (artifacts !== void 0) {
+        console.error(`Artifacts written to ${options.output}`);
+      }
+    } else {
+      console.log(renderCohortReport(result, { format: "markdown" }));
+      if (artifacts !== void 0) {
+        console.log("");
+        console.log(`Artifacts:`);
+        console.log(`- ${artifacts.jsonPath}`);
+        console.log(`- ${artifacts.markdownPath}`);
+        console.log(`- ${artifacts.htmlPath}`);
+      }
+    }
+    if (!result.ok) process.exitCode = 1;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (options.json) {
+      console.log(JSON.stringify({ ok: false, error: message }, null, 2));
+    } else {
+      console.error(`[AgentInspect] cohort failed: ${message}`);
+    }
+    process.exitCode = 1;
+  }
+}
+
 // packages/cli/src/index.ts
 function runCommand(action) {
   void action().catch((error) => {
@@ -20311,6 +20977,12 @@ function createCliProgram() {
   suiteCmd.command("report").description("Render a report from a prior suite run artifact").option("--input <path>", "suite run JSON artifact").option("--format <format>", "markdown or json", "markdown").option("--json", "print JSON wrapper").action((opts) => {
     runCommand(() => suiteReportCommand(opts));
   });
+  program.command("cohort").description("Compare baseline/candidate trace cohorts for regressions (v5.1+)").option("--dir <path>", "trace directory").option("--baseline <label>", "baseline cohort label (metadata key)").option("--candidate <label>", "candidate cohort label (metadata key)").option("--cohort-key <key>", "metadata key for cohort labels", "cohort").option("--group-by <spec>", "model | session | group | metadata.<key>", "model").option(
+    "--metric <list>",
+    "comma-separated metrics (errorRate,duration,toolChoice,...)"
+  ).option("--format <format>", "markdown, json, or html", "markdown").option("-o, --output <dir>", "write cohort-results.json, cohort-summary.md, cohort-report.html").option("--json", "print deterministic JSON result").action((opts) => {
+    runCommand(() => cohortCommand(opts));
+  });
   return program;
 }
 function isPrimaryModule() {