agent-inspect 2.0.0 → 2.2.0

package/packages/cli/dist/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { realpathSync, createReadStream } from 'fs';
-import path10 from 'path';
+import path13 from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { Command, Option } from 'commander';
 import { AsyncLocalStorage } from 'async_hooks';
@@ -12,7 +12,7 @@ import tty from 'tty';
 import { createInterface } from 'readline';
 
 // package.json
-var version = "2.0.0";
+var version = "2.2.0";
 
 // packages/core/src/correlation-metadata.ts
 var TRACE_CORRELATION_KEYS = [
@@ -744,7 +744,7 @@ function formatDuration(ms) {
 // packages/core/src/utils.ts
 var DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
 var RUNS_DIR_NAME = "runs";
-var FALLBACK_TRACE_DIR = path10.join(
+var FALLBACK_TRACE_DIR = path13.join(
   os.tmpdir(),
   "agent-inspect",
   RUNS_DIR_NAME
@@ -779,7 +779,7 @@ function getDefaultTraceDir() {
     if (typeof home !== "string" || home.trim() === "") {
       return FALLBACK_TRACE_DIR;
     }
-    return path10.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
+    return path13.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
   } catch {
     return FALLBACK_TRACE_DIR;
   }
@@ -787,11 +787,11 @@ function getDefaultTraceDir() {
 function getTraceFilePath(runId, traceDir) {
   const baseDir = traceDir ?? getDefaultTraceDir();
   let safeId = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "run_unknown";
-  safeId = path10.basename(safeId);
+  safeId = path13.basename(safeId);
   if (safeId === "" || safeId === "." || safeId === "..") {
     safeId = "run_unknown";
   }
-  return path10.join(baseDir, `${safeId}.jsonl`);
+  return path13.join(baseDir, `${safeId}.jsonl`);
 }
 function formatError(error) {
   if (error instanceof Error) {
@@ -1553,7 +1553,7 @@ var TraceDirectory = class {
     this.#dir = resolveTraceDir(options);
   }
   getPath(filename) {
-    return filename ? path10.join(this.#dir, filename) : this.#dir;
+    return filename ? path13.join(this.#dir, filename) : this.#dir;
   }
   async list() {
     try {
@@ -1580,7 +1580,7 @@ function parseIsoToMs2(value) {
 }
 async function extractMetadata(filePath, _quickScan) {
   const stats = await stat(filePath);
-  let runIdFromFile = path10.basename(filePath);
+  let runIdFromFile = path13.basename(filePath);
   if (runIdFromFile.endsWith(".jsonl")) {
     runIdFromFile = runIdFromFile.slice(0, -".jsonl".length);
   }
@@ -3551,7 +3551,7 @@ function findReaderByFormat(format, readers) {
 }
 async function jsonlFilesInDirectory(dirPath) {
   const entries = await readdir(dirPath, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path10.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path13.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
 }
 async function resolveInput(input3) {
   const cached = resolvedInputCache.get(input3);
@@ -5294,11 +5294,11 @@ function isRecord9(v) {
 function isNonEmptyStringArray(v) {
   return Array.isArray(v) && v.length > 0 && v.every((x) => typeof x === "string" && x.trim() !== "");
 }
-function validateRedact(redact) {
-  if (!Array.isArray(redact)) {
+function validateRedact(redact2) {
+  if (!Array.isArray(redact2)) {
     throw new Error("Invalid config: redact must be an array");
   }
-  for (const r of redact) {
+  for (const r of redact2) {
     if (typeof r === "string") continue;
     if (!isRecord9(r)) {
       throw new Error("Invalid config: redact entries must be strings or objects");
@@ -7677,9 +7677,9 @@ Trace directory: ${traceDir}`);
   if (validation !== void 0 && !validation.ok) {
     process.exitCode = 1;
   }
-  const outPath = options.output !== void 0 && options.output.trim() !== "" ? path10.resolve(options.output.trim()) : void 0;
+  const outPath = options.output !== void 0 && options.output.trim() !== "" ? path13.resolve(options.output.trim()) : void 0;
   if (outPath !== void 0) {
-    await mkdir(path10.dirname(outPath), { recursive: true });
+    await mkdir(path13.dirname(outPath), { recursive: true });
     await writeFile(outPath, result.content, "utf-8");
     const vlabel = validation !== void 0 ? validation.ok ? "ok" : "failed" : "skipped";
     console.log(`Wrote ${result.fileExtension} export to ${outPath} (validation: ${vlabel})`);
@@ -7856,13 +7856,13 @@ function pairSteps(left, right) {
   return pairs;
 }
 function compareLeafSteps(L, R, segments, opts, out) {
-  const path12 = buildPath(segments);
+  const path15 = buildPath(segments);
   if (L.name !== R.name) {
     out.push({
       kind: "structure",
       severity: "warning",
       message: "Step name differs",
-      path: path12,
+      path: path15,
       left: L.name,
       right: R.name
     });
@@ -7872,7 +7872,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-type",
       severity: "warning",
       message: "Step type differs",
-      path: path12,
+      path: path15,
       left: L.type,
       right: R.type
     });
@@ -7882,7 +7882,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-status",
       severity: "warning",
       message: "Step status differs",
-      path: path12,
+      path: path15,
       left: L.status,
       right: R.status
     });
@@ -7894,7 +7894,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "error",
       severity: "error",
       message: "Step error message differs",
-      path: path12,
+      path: path15,
       left: le || void 0,
       right: re || void 0
     });
@@ -7912,7 +7912,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
         kind: "duration",
         severity: "info",
         message: "Step duration differs",
-        path: path12,
+        path: path15,
         left: ld,
         right: rd
       });
@@ -7925,7 +7925,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "metadata",
       severity: "info",
       message: "Step metadata differs",
-      path: path12,
+      path: path15,
       left: L.metadata,
       right: R.metadata
     });
@@ -7937,7 +7937,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "output",
       severity: "info",
       message: "Output preview differs",
-      path: path12,
+      path: path15,
       left: L.outputPreview,
       right: R.outputPreview
     });
@@ -8097,11 +8097,11 @@ function diffRuns(left, right, options) {
 }
 
 // packages/core/src/diff/renderer.ts
-function formatPath(path12) {
-  if (path12 === void 0 || path12.path.length === 0) {
+function formatPath(path15) {
+  if (path15 === void 0 || path15.path.length === 0) {
     return "(run)";
   }
-  return path12.path.map((s) => s.name).join(" > ");
+  return path15.path.map((s) => s.name).join(" > ");
 }
 function formatValue(v, verbose) {
   if (v === void 0) return "(undefined)";
@@ -8532,9 +8532,9 @@ async function reportCommand(runId, options = {}) {
     redactionProfile,
     correlation: !options.noCorrelation
   });
-  const outPath = options.output !== void 0 && options.output.trim() !== "" ? path10.resolve(options.output.trim()) : void 0;
+  const outPath = options.output !== void 0 && options.output.trim() !== "" ? path13.resolve(options.output.trim()) : void 0;
   if (outPath !== void 0) {
-    await mkdir(path10.dirname(outPath), { recursive: true });
+    await mkdir(path13.dirname(outPath), { recursive: true });
     await writeFile(outPath, result.content, "utf-8");
     console.log(`Wrote ${result.fileExtension} report to ${outPath}`);
   }
@@ -8554,6 +8554,383 @@ async function reportCommand(runId, options = {}) {
     console.log(result.content);
   }
 }
+var DEFAULT_REDACT_KEYS2 = [
+  "authorization",
+  "cookie",
+  "token",
+  "apiKey",
+  "password",
+  "secret",
+  "email"
+];
+var SHARE_PROFILE_EXTRA_KEYS2 = [
+  "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_KEYS2 = [
+  "prompt",
+  "completion",
+  "input",
+  "output",
+  "inputPreview",
+  "outputPreview",
+  "message",
+  "messages",
+  "transcript",
+  "context",
+  "document",
+  "documents",
+  "chunk",
+  "chunks",
+  "retrieval",
+  "query"
+];
+function isRecord13(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toKey2(key) {
+  return key.toLowerCase();
+}
+function stableHash2(value) {
+  const hash = crypto.createHash("sha256").update(value, "utf8").digest("hex");
+  return hash.slice(0, 8);
+}
+function stringifyScalar(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  return void 0;
+}
+function patternDetector(options) {
+  return {
+    id: options.id,
+    severity: options.severity ?? "warning",
+    matchKind: "value",
+    detect(input3) {
+      if (typeof input3.value !== "string") return [];
+      options.pattern.lastIndex = 0;
+      return options.pattern.test(input3.value) ? [{ action: "replace", severity: options.severity ?? "warning", matchKind: "value" }] : [];
+    }
+  };
+}
+function digitsOnly(value) {
+  return value.replace(/\D/g, "");
+}
+function passesLuhn(value) {
+  const digits = digitsOnly(value);
+  if (digits.length < 13 || digits.length > 19) return false;
+  let sum = 0;
+  let double = false;
+  for (let i = digits.length - 1; i >= 0; i -= 1) {
+    let digit = Number(digits[i]);
+    if (double) {
+      digit *= 2;
+      if (digit > 9) digit -= 9;
+    }
+    sum += digit;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
+var credentialDetectors = [
+  patternDetector({
+    id: "value.authorizationHeader",
+    pattern: /^(?:basic|bearer|digest|apikey)\s+[a-z0-9._~+/=-]+$/i,
+    severity: "error"
+  }),
+  patternDetector({
+    id: "value.bearerToken",
+    pattern: /\bbearer\s+[a-z0-9._~+/=-]{12,}\b/i,
+    severity: "error"
+  }),
+  patternDetector({
+    id: "value.cookie",
+    pattern: /\b[a-z0-9_.-]+=[^;\s]+(?:;\s*[a-z0-9_.-]+=[^;\s]+)+/i,
+    severity: "error"
+  }),
+  patternDetector({
+    id: "value.jwt",
+    pattern: /\beyJ[a-zA-Z0-9_-]{8,}\.[a-zA-Z0-9_-]{8,}\.[a-zA-Z0-9_-]{8,}\b/,
+    severity: "error"
+  }),
+  patternDetector({
+    id: "value.providerApiKey",
+    pattern: /\b(?:sk-(?:proj-)?[a-zA-Z0-9_-]{16,}|sk-ant-[a-zA-Z0-9_-]{16,}|AIza[0-9A-Za-z_-]{20,})\b/,
+    severity: "error"
+  }),
+  patternDetector({
+    id: "value.githubToken",
+    pattern: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{20,}\b/,
+    severity: "error"
+  }),
+  patternDetector({
+    id: "value.awsAccessKey",
+    pattern: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/,
+    severity: "error"
+  }),
+  patternDetector({
+    id: "value.privateKey",
+    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*-----END [A-Z ]*PRIVATE KEY-----/,
+    severity: "error"
+  }),
+  {
+    id: "value.creditCard",
+    severity: "error",
+    matchKind: "value",
+    detect(input3) {
+      if (typeof input3.value !== "string") return [];
+      const candidatePattern = /(?:\d[ -]?){13,19}/g;
+      for (const match of input3.value.matchAll(candidatePattern)) {
+        const candidate = match[0] ?? "";
+        if (passesLuhn(candidate)) {
+          return [{ action: "replace", severity: "error", matchKind: "value" }];
+        }
+      }
+      return [];
+    }
+  }
+];
+var identifierDetectors = [
+  patternDetector({
+    id: "value.email",
+    pattern: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i
+  }),
+  patternDetector({
+    id: "value.phone",
+    pattern: /\b(?:\+\d{1,3}[\s.-]?)?(?:\(?\d{3}\)?[\s.-])\d{3}[\s.-]\d{4}\b/
+  }),
+  patternDetector({
+    id: "value.ipv4",
+    pattern: /\b(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)\b/
+  }),
+  patternDetector({
+    id: "value.ipv6",
+    pattern: /\b(?:[0-9a-f]{1,4}:){2,7}[0-9a-f]{1,4}\b/i
+  })
+];
+function builtInDetectorsForProfile(profile) {
+  if (profile === "local") return credentialDetectors;
+  return [...credentialDetectors, ...identifierDetectors];
+}
+function compileRules2(rules, extraKeys) {
+  const out = /* @__PURE__ */ new Map();
+  const set = (rule) => {
+    const key = toKey2(rule.key);
+    out.set(key, { ...rule, key });
+  };
+  for (const key of DEFAULT_REDACT_KEYS2) {
+    set({ key, strategy: "full" });
+  }
+  for (const key of extraKeys ?? []) {
+    if (typeof key === "string" && key.length > 0) {
+      set({ key, strategy: "full" });
+    }
+  }
+  for (const rule of rules ?? []) {
+    if (typeof rule === "string") {
+      set({ key: rule, strategy: "full" });
+      continue;
+    }
+    if (rule.strategy === "full") set({ key: rule.key, strategy: "full" });
+    if (rule.strategy === "hash") set({ key: rule.key, strategy: "hash" });
+    if (rule.strategy === "prefix") {
+      set({
+        key: rule.key,
+        strategy: "prefix",
+        keep: typeof rule.keep === "number" ? rule.keep : 8
+      });
+    }
+  }
+  return [...out.values()];
+}
+function actionForRule(rule) {
+  if (rule.strategy === "full") return "replace";
+  return rule.strategy;
+}
+function applyRule(rule, value, replacement) {
+  if (rule.strategy === "full") return replacement;
+  const asString = stringifyScalar(value);
+  if (rule.strategy === "prefix") {
+    if (asString === void 0) return replacement;
+    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:${stableHash2(asString)}]`;
+  }
+  return value;
+}
+function childPath(path15, key) {
+  if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) {
+    return path15 ? `${path15}.${key}` : key;
+  }
+  return `${path15 || "$"}[${JSON.stringify(key)}]`;
+}
+function indexPath(path15, index) {
+  return `${path15 || "$"}[${index}]`;
+}
+function makeFinding(path15, detector, action, matchKind, severity = "warning", preview) {
+  return preview === void 0 ? { path: path15, detector, action, severity, matchKind } : { path: path15, detector, action, severity, matchKind, preview };
+}
+function createRedactionProfile(profile = "local") {
+  switch (profile) {
+    case "local":
+      return { profile: "local", extraKeys: [] };
+    case "share":
+      return {
+        profile: "share",
+        extraKeys: SHARE_PROFILE_EXTRA_KEYS2,
+        maxMetadataValueLengthCap: 500,
+        maxPreviewLengthCap: 200
+      };
+    case "strict":
+      return {
+        profile: "strict",
+        extraKeys: [...SHARE_PROFILE_EXTRA_KEYS2, ...STRICT_PROFILE_EXTRA_KEYS2],
+        maxMetadataValueLengthCap: 200,
+        maxPreviewLengthCap: 80
+      };
+  }
+}
+var Redactor2 = class {
+  #rules;
+  #detectors;
+  #profile;
+  #replacement;
+  #maxDepth;
+  #collectFindings;
+  constructor(options) {
+    const resolved = createRedactionProfile(options?.profile ?? "local");
+    this.#profile = resolved.profile;
+    this.#rules = compileRules2(options?.rules, [
+      ...resolved.extraKeys,
+      ...options?.extraKeys ?? []
+    ]);
+    this.#detectors = [
+      ...builtInDetectorsForProfile(this.#profile),
+      ...options?.detectors ?? []
+    ];
+    this.#replacement = options?.replacement ?? "[REDACTED]";
+    this.#maxDepth = options?.maxDepth ?? 32;
+    this.#collectFindings = options?.collectFindings ?? true;
+  }
+  redactValue(key, value) {
+    return this.#redactValue(value, key, key, 0, {
+      findings: [],
+      seen: /* @__PURE__ */ new WeakMap()
+    });
+  }
+  redactRecord(record) {
+    return this.redact(record).value;
+  }
+  redact(value) {
+    const state = {
+      findings: [],
+      seen: /* @__PURE__ */ new WeakMap()
+    };
+    const redacted = this.#redactValue(value, void 0, "$", 0, state);
+    return {
+      value: redacted,
+      findings: state.findings,
+      redacted: state.findings.some((finding) => finding.action !== "keep"),
+      profile: this.#profile
+    };
+  }
+  #recordFinding(state, finding) {
+    if (this.#collectFindings) state.findings.push(finding);
+  }
+  #redactValue(value, key, path15, depth, state) {
+    if (depth > this.#maxDepth) {
+      this.#recordFinding(
+        state,
+        makeFinding(path15, "structure.maxDepth", "truncate", "value", "warning")
+      );
+      return "[Truncated]";
+    }
+    if (key !== void 0) {
+      const rule = this.#rules.find((candidate) => candidate.key === toKey2(key));
+      if (rule) {
+        this.#recordFinding(
+          state,
+          makeFinding(path15, `key.${rule.key}`, actionForRule(rule), "key", "warning")
+        );
+        return applyRule(rule, value, this.#replacement);
+      }
+    }
+    for (const detector of this.#detectors) {
+      const detections = detector.detect({ path: path15, key, value });
+      for (const detection of detections) {
+        const action = detection.action ?? "replace";
+        this.#recordFinding(
+          state,
+          makeFinding(
+            path15,
+            detector.id,
+            action,
+            detection.matchKind ?? detector.matchKind ?? "custom",
+            detection.severity ?? detector.severity ?? "warning",
+            detection.preview
+          )
+        );
+        if (action !== "keep") {
+          return detection.replacement ?? this.#replacement;
+        }
+      }
+    }
+    if (Array.isArray(value)) {
+      if (state.seen.has(value)) return state.seen.get(value);
+      const out = [];
+      state.seen.set(value, out);
+      value.forEach((item, index) => {
+        out[index] = this.#redactValue(item, void 0, indexPath(path15, index), depth + 1, state);
+      });
+      return out;
+    }
+    if (isRecord13(value)) {
+      if (state.seen.has(value)) return state.seen.get(value);
+      const out = {};
+      state.seen.set(value, out);
+      for (const [entryKey, entryValue] of Object.entries(value)) {
+        out[entryKey] = this.#redactValue(
+          entryValue,
+          entryKey,
+          childPath(path15 === "$" ? "" : path15, entryKey),
+          depth + 1,
+          state
+        );
+      }
+      return out;
+    }
+    return value;
+  }
+};
+function createRedactor(options) {
+  return new Redactor2(options);
+}
+function redact(value, options) {
+  return createRedactor(options).redact(value);
+}
 async function readStdin(stdin) {
   stdin.setEncoding("utf8");
   let content = "";
@@ -8582,8 +8959,119 @@ async function inputFromTarget(target, options, stdin) {
   return { type: "file", path: runPath };
 }
 
-// packages/cli/src/explain.ts
+// packages/cli/src/redact.ts
 function parseRedactionProfile3(value) {
+  if (value === void 0 || value === "local" || value === "share" || value === "strict") {
+    return value ?? "share";
+  }
+  throw new Error(`Unsupported --profile "${value}". Use local, share, or strict.`);
+}
+function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (value === null || typeof value !== "object") return value;
+  const record = value;
+  return Object.fromEntries(
+    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable(record[key])])
+  );
+}
+function isMissingFileError3(error) {
+  return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+async function contentFromTarget(target, options, stdin) {
+  if (target === "-") {
+    return { content: await readStdin(stdin), source: "stdin" };
+  }
+  try {
+    const stats2 = await stat(target);
+    if (stats2.isDirectory()) {
+      throw new Error("redact requires a trace file, JSON file, stdin, or run id.");
+    }
+    return { content: await readFile(target, "utf-8"), source: target };
+  } catch (error) {
+    if (!isMissingFileError3(error)) throw error;
+  }
+  const runPath = getTraceFilePath(target, resolveTraceDir({ dir: options.dir }));
+  const stats = await stat(runPath);
+  if (stats.isDirectory()) {
+    throw new Error("redact requires a trace file, JSON file, stdin, or run id.");
+  }
+  return { content: await readFile(runPath, "utf-8"), source: runPath };
+}
+function redactJsonText(content, profile) {
+  const parsed = JSON.parse(content);
+  const result = redact(parsed, { profile });
+  return {
+    content: `${JSON.stringify(result.value, null, 2)}
+`,
+    findings: result.findings
+  };
+}
+function redactJsonlText(content, profile) {
+  const lines = content.split(/\r?\n/);
+  const out = [];
+  const findings = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    if (line.trim() === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      throw new Error(`Input is not valid JSON or JSONL at line ${index + 1}.`);
+    }
+    const result = redact(parsed, { profile });
+    out.push(JSON.stringify(result.value));
+    findings.push(
+      ...result.findings.map((finding) => ({
+        ...finding,
+        path: `line:${index + 1}:${finding.path}`
+      }))
+    );
+  }
+  return {
+    content: out.length === 0 ? "" : `${out.join("\n")}
+`,
+    findings
+  };
+}
+function redactDocument(content, profile) {
+  try {
+    return redactJsonText(content, profile);
+  } catch {
+    return redactJsonlText(content, profile);
+  }
+}
+async function redactCommand(target, options = {}, stdin = process.stdin) {
+  const profile = parseRedactionProfile3(options.profile);
+  const source = await contentFromTarget(target, options, stdin);
+  const redacted = redactDocument(source.content, profile);
+  if (options.output !== void 0) {
+    await writeFile(options.output, redacted.content, "utf-8");
+  }
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        stable({
+          ok: true,
+          profile,
+          source: source.source,
+          output: options.output,
+          findings: redacted.findings,
+          content: options.output === void 0 ? redacted.content : void 0
+        }),
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (options.output === void 0) {
+    process.stdout.write(redacted.content);
+  }
+}
+
+// packages/cli/src/explain.ts
+function parseRedactionProfile4(value) {
   const profile = (value ?? "local").trim().toLowerCase();
   if (profile === "local" || profile === "share" || profile === "strict") {
     return profile;
@@ -8654,7 +9142,7 @@ async function explainCommand(target, options = {}, stdin = process.stdin) {
   }
   let redactionProfile;
   try {
-    redactionProfile = parseRedactionProfile3(options.redactionProfile);
+    redactionProfile = parseRedactionProfile4(options.redactionProfile);
   } catch (error) {
     process.exitCode = 1;
     console.error(error instanceof Error ? error.message : String(error));
@@ -8852,7 +9340,7 @@ async function openCommand(input3, options = {}, stdin = process.stdin) {
     }
   }
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseTarget(value) {
@@ -8861,7 +9349,7 @@ function parseTarget(value) {
   throw new Error('Unsupported migration target. Use "--to 1.0".');
 }
 function formatOf(value) {
-  if (!isRecord13(value)) return "unknown";
+  if (!isRecord14(value)) return "unknown";
   if (value.schemaVersion === "0.1") return "0.1";
   if (value.schemaVersion === "0.2") return "0.2";
   if (value.schemaVersion === "1.0") return "1.0";
@@ -8874,14 +9362,14 @@ function uniqueSorted(values) {
   return [...new Set(values)].sort();
 }
 function isWithinDirectory(child, parent) {
-  const relative = path10.relative(parent, child);
-  return relative === "" || !relative.startsWith("..") && !path10.isAbsolute(relative);
+  const relative = path13.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path13.isAbsolute(relative);
 }
 async function resolveOutputPath(inputPath, output2, force) {
   if (output2 === void 0 || output2.trim() === "") return void 0;
-  const inputAbs = path10.resolve(inputPath);
-  const outputAbs = path10.resolve(output2.trim());
-  const inputDir = path10.dirname(inputAbs);
+  const inputAbs = path13.resolve(inputPath);
+  const outputAbs = path13.resolve(output2.trim());
+  const inputDir = path13.dirname(inputAbs);
   if (!isWithinDirectory(outputAbs, inputDir)) {
     throw new Error("Refusing to write migrated output outside the input directory.");
   }
@@ -9002,7 +9490,7 @@ async function migrateCommand(input3, options = {}) {
     process.exitCode = 1;
     return;
   }
-  const inputPath = path10.resolve(input3.trim());
+  const inputPath = path13.resolve(input3.trim());
   const dryRun = options.dryRun === true;
   if (!dryRun && (options.output === void 0 || options.output.trim() === "")) {
     console.error("migrate requires --dry-run or --output <path>.");
@@ -9021,7 +9509,7 @@ async function migrateCommand(input3, options = {}) {
     );
     const result = await buildMigration(inputPath, outputPath);
     if (!dryRun && outputPath !== void 0) {
-      await mkdir(path10.dirname(outputPath), { recursive: true });
+      await mkdir(path13.dirname(outputPath), { recursive: true });
       await writeFile(outputPath, result.content, "utf-8");
     }
     printSummary2(result, dryRun);
@@ -9299,7 +9787,7 @@ function stripPrefix(name, prefixes) {
   }
   return name;
 }
-function eventEvidence(event, path12) {
+function eventEvidence(event, path15) {
   return {
     runId: event.runId,
     eventId: event.eventId,
@@ -9309,7 +9797,7 @@ function eventEvidence(event, path12) {
     kind: event.kind,
     name: event.name,
     status: event.status,
-    ...path12 ? { path: path12 } : {}
+    ...path15 ? { path: path15 } : {}
   };
 }
 function runEvidence(run) {
@@ -9346,7 +9834,7 @@ function finishedEvents(context, kind) {
     (event) => (kind === void 0 || event.kind === kind) && event.status !== "running"
   );
 }
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function eventMap(events) {
@@ -9372,9 +9860,9 @@ function eventEndMs(event) {
 function normalizedKey(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]/g, "");
 }
-function lastPathSegment(path12) {
-  const parts = path12.split(".");
-  return parts[parts.length - 1] ?? path12;
+function lastPathSegment(path15) {
+  const parts = path15.split(".");
+  return parts[parts.length - 1] ?? path15;
 }
 function valueType(value) {
   if (Array.isArray(value)) return "array";
@@ -9388,22 +9876,22 @@ function serializedByteLength(value) {
     return void 0;
   }
 }
-function pushValueEntries(entries, event, value, path12, key, depth = 0) {
-  entries.push({ event, path: path12, key, value });
+function pushValueEntries(entries, event, value, path15, key, depth = 0) {
+  entries.push({ event, path: path15, key, value });
   if (depth >= 8) return;
   if (Array.isArray(value)) {
     for (const [index, item] of value.entries()) {
-      pushValueEntries(entries, event, item, `${path12}.${index}`, String(index), depth + 1);
+      pushValueEntries(entries, event, item, `${path15}.${index}`, String(index), depth + 1);
     }
     return;
   }
-  if (!isRecord14(value)) return;
+  if (!isRecord15(value)) return;
   for (const nestedKey of Object.keys(value).sort((a, b) => a.localeCompare(b))) {
     pushValueEntries(
       entries,
       event,
       value[nestedKey],
-      `${path12}.${nestedKey}`,
+      `${path15}.${nestedKey}`,
       nestedKey,
       depth + 1
     );
@@ -9484,9 +9972,9 @@ function eventDurationMs(event) {
 }
 function treeShape(nodes) {
   const lines = [];
-  const visit = (node, path12) => {
-    lines.push(`${path12}:${node.event.kind}:${node.event.name}:${node.event.status ?? "unknown"}`);
-    node.children.forEach((child, index) => visit(child, `${path12}.${index}`));
+  const visit = (node, path15) => {
+    lines.push(`${path15}:${node.event.kind}:${node.event.name}:${node.event.status ?? "unknown"}`);
+    node.children.forEach((child, index) => visit(child, `${path15}.${index}`));
   };
   nodes.forEach((node, index) => visit(node, String(index)));
   return lines;
@@ -9535,9 +10023,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, path12) {
+function firstEvidenceForKind(context, kind, path15) {
   const event = context.events.find((candidate) => candidate.kind === kind);
-  return event ? [eventEvidence(event, path12)] : runEvidence(context.selectedRun);
+  return event ? [eventEvidence(event, path15)] : runEvidence(context.selectedRun);
 }
 function baselineDiffFinding(message, evidence, expected, actual) {
   return failFinding("baseline.regression", message, evidence, expected, actual);
@@ -9785,13 +10273,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 path12 = [];
+        const path15 = [];
         const seenAt = /* @__PURE__ */ new Map();
         let current = event;
         while (current) {
           const existing = seenAt.get(current.eventId);
           if (existing !== void 0) {
-            const cycle = path12.slice(existing);
+            const cycle = path15.slice(existing);
             const key = cycle.map((item) => item.eventId).sort().join("\0");
             if (!seenCycles.has(key)) {
               seenCycles.add(key);
@@ -9807,8 +10295,8 @@ function createStructureCycleRule() {
             }
             break;
           }
-          seenAt.set(current.eventId, path12.length);
-          path12.push(current);
+          seenAt.set(current.eventId, path15.length);
+          path15.push(current);
           current = current.parentId ? byId.get(current.parentId) : void 0;
         }
       }
@@ -10082,7 +10570,7 @@ function createSafetyOversizedAttributeRule(options) {
               )
             );
           }
-          if (isRecord14(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
+          if (isRecord15(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
             findings.push(
               failFinding(
                 "safety.oversizedAttribute",
@@ -10333,7 +10821,7 @@ function asConfig(value) {
 }
 async function loadConfig(configPath) {
   if (configPath === void 0) return {};
-  const extension = path10.extname(configPath);
+  const extension = path13.extname(configPath);
   if (TS_CONFIG_EXTENSIONS.has(extension)) {
     throw new Error(
       "TypeScript check configs require an explicit precompiled JavaScript config or future --config-loader support."
@@ -10342,7 +10830,7 @@ async function loadConfig(configPath) {
   if (!CONFIG_EXTENSIONS.has(extension)) {
     throw new Error("Unsupported check config extension. Use .json, .js, .mjs, or .cjs.");
   }
-  const absolute = path10.resolve(configPath);
+  const absolute = path13.resolve(configPath);
   if (extension === ".json") {
     const raw = await readFile(absolute, "utf-8");
     return asConfig(JSON.parse(raw));
@@ -10359,12 +10847,12 @@ function normalizeConfig(config) {
 }
 function buildRules(config, options) {
   const diagnostics = [];
-  const checks = normalizeConfig(config);
-  const run = checks.run ?? {};
-  const tool = checks.tool ?? {};
-  const llm = checks.llm ?? {};
-  const structure = checks.structure ?? {};
-  const safety = checks.safety ?? {};
+  const checks2 = normalizeConfig(config);
+  const run = checks2.run ?? {};
+  const tool = checks2.tool ?? {};
+  const llm = checks2.llm ?? {};
+  const structure = checks2.structure ?? {};
+  const safety = checks2.safety ?? {};
   const maxDurationMs = parseNumber(options.maxDurationMs, "--max-duration-ms") ?? run.maxDurationMs;
   const maxTotalTokens = parseNumber(options.maxTotalTokens, "--max-total-tokens") ?? llm.maxTotalTokens;
   const rules = [
@@ -10412,7 +10900,7 @@ function buildRules(config, options) {
     rules.push(createSafetyOversizedAttributeRule(safety));
   }
   const select = [
-    ...asStringArray(checks.select) ?? [],
+    ...asStringArray(checks2.select) ?? [],
     ...options.rule ?? []
   ];
   return {
@@ -10442,16 +10930,16 @@ function exitCodeFor(result) {
   }
   return 1;
 }
-function stable(value) {
-  if (Array.isArray(value)) return value.map(stable);
+function stable2(value) {
+  if (Array.isArray(value)) return value.map(stable2);
   if (value === null || typeof value !== "object") return value;
   const record = value;
   return Object.fromEntries(
-    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable(record[key])])
+    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable2(record[key])])
   );
 }
 function printJson(result) {
-  console.log(JSON.stringify(stable(result), null, 2));
+  console.log(JSON.stringify(stable2(result), null, 2));
 }
 function printHuman(result) {
   console.log(`Check status: ${result.status}`);
@@ -10460,12 +10948,12 @@ function printHuman(result) {
   console.log(
     `Summary: ${result.summary.failed} failed, ${result.summary.warnings} warning(s), ${result.summary.errors} error(s)`
   );
-  for (const diagnostic3 of result.diagnostics) {
-    console.log(`- ${diagnostic3.code}: ${diagnostic3.message}`);
+  for (const diagnostic4 of result.diagnostics) {
+    console.log(`- ${diagnostic4.code}: ${diagnostic4.message}`);
   }
   for (const finding of result.findings) {
-    const path12 = finding.evidence[0]?.path;
-    console.log(`- ${finding.ruleId}: ${finding.message}${path12 ? ` (${path12})` : ""}`);
+    const path15 = finding.evidence[0]?.path;
+    console.log(`- ${finding.ruleId}: ${finding.message}${path15 ? ` (${path15})` : ""}`);
   }
 }
 function readErrorResult(error) {
@@ -10519,42 +11007,996 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
   else printHuman(result);
 }
 
-// packages/cli/src/safety.ts
-var BEST_EFFORT_NOTE = "Best-effort local safety verification only; not a compliance, privacy, security, or regulatory certification.";
-var DEFAULT_MAX_STRING_LENGTH = 16384;
-var DEFAULT_MAX_ARRAY_LENGTH = 1e3;
-var DEFAULT_MAX_OBJECT_KEYS = 200;
-var DEFAULT_MAX_SERIALIZED_BYTES = 128 * 1024;
-function parseLimit3(value, label) {
-  if (value === void 0) return void 0;
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed < 0) {
-    throw new Error(`${label} must be a non-negative number.`);
+// packages/eval/src/index.ts
+function isTraceReadResult(value) {
+  return value !== null && typeof value === "object" && "runs" in value && "events" in value && "format" in value;
+}
+function traceInputFrom(value) {
+  return { type: "file", path: value instanceof URL ? value.pathname : value };
+}
+async function resolveRead(input3, options) {
+  try {
+    if (typeof input3 === "string") {
+      const read2 = await openTrace(traceInputFrom(input3), {
+        ...options.format !== void 0 && options.format !== "auto" ? { format: options.format } : {}
+      });
+      return { read: read2, runId: options.runId, diagnostics: [] };
+    }
+    if (isTraceReadResult(input3)) {
+      return { read: input3, runId: options.runId, diagnostics: [] };
+    }
+    if (isTraceReadResult(input3.trace)) {
+      return { read: input3.trace, runId: options.runId ?? input3.runId, diagnostics: [] };
+    }
+    const format = options.format ?? input3.format;
+    const read = await openTrace(traceInputFrom(input3.trace), {
+      ...format !== void 0 && format !== "auto" ? { format } : {}
+    });
+    return { read, runId: options.runId ?? input3.runId, diagnostics: [] };
+  } catch (error) {
+    return { diagnostics: [diagnosticFromError(error)] };
   }
-  return parsed;
 }
-function stable2(value) {
-  if (Array.isArray(value)) return value.map(stable2);
-  if (value === null || typeof value !== "object") return value;
-  const record = value;
-  return Object.fromEntries(
-    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable2(record[key])])
-  );
+function diagnosticFromError(error) {
+  if (error instanceof TraceReadError) {
+    const code = error.code === "unsupported_format" ? "AI_EVAL_UNSUPPORTED_FORMAT" : error.code === "ambiguous_format" ? "AI_EVAL_AMBIGUOUS_FORMAT" : "AI_EVAL_TRACE_UNREADABLE";
+    return { code, severity: "error", message: error.message };
+  }
+  return {
+    code: "AI_EVAL_TRACE_UNREADABLE",
+    severity: "error",
+    message: error instanceof Error ? error.message : String(error)
+  };
 }
-function safetyDiagnostic(code, message, severity = "error") {
-  return { code, message, severity };
+function flatten2(nodes) {
+  return nodes.flatMap((node) => [node, ...flatten2(node.children)]);
 }
-function warningDiagnostics(warnings, unsupportedFields) {
-  return [
-    ...warnings.map(
-      (warning) => safetyDiagnostic(
-        warning.code,
-        warning.message,
-        warning.severity === "error" ? "error" : "warning"
-      )
-    ),
-    ...unsupportedFields.map(
-      (field) => safetyDiagnostic(
+function selectRun3(read, runId) {
+  if (runId !== void 0) {
+    const run = read.runs.find((candidate) => candidate.runId === runId);
+    return run === void 0 ? {
+      diagnostics: [
+        {
+          code: "AI_EVAL_RUN_SELECTION_REQUIRED",
+          severity: "error",
+          message: `Run not found: ${runId}.`
+        }
+      ]
+    } : { run, diagnostics: [] };
+  }
+  if (read.runs.length === 1) {
+    return { run: read.runs[0], diagnostics: [] };
+  }
+  if (read.runs.length === 0) {
+    return {
+      diagnostics: [
+        {
+          code: "AI_EVAL_RUN_SELECTION_REQUIRED",
+          severity: "error",
+          message: "No runs are available for eval."
+        }
+      ]
+    };
+  }
+  return {
+    diagnostics: [
+      {
+        code: "AI_EVAL_RUN_SELECTION_REQUIRED",
+        severity: "error",
+        message: "Multiple runs are available; select a run before eval."
+      }
+    ]
+  };
+}
+function errorResult3(format, diagnostics, runId) {
+  const errors = diagnostics.filter((item) => item.severity === "error").length;
+  return {
+    ok: false,
+    status: "error",
+    format,
+    ...runId !== void 0 ? { runId } : {},
+    summary: { passed: 0, failed: 0, warnings: 0, errors },
+    findings: [],
+    diagnostics: [...diagnostics]
+  };
+}
+function normalizeFinding2(rule, finding) {
+  return {
+    ...finding,
+    ruleId: finding.ruleId || rule.id,
+    severity: finding.severity ?? rule.severity ?? "error",
+    evidence: [...finding.evidence]
+  };
+}
+function compareFindings2(a, b) {
+  const aEvidence = a.evidence[0];
+  const bEvidence = b.evidence[0];
+  return a.ruleId.localeCompare(b.ruleId) || (aEvidence?.runId ?? "").localeCompare(bEvidence?.runId ?? "") || (aEvidence?.eventId ?? "").localeCompare(bEvidence?.eventId ?? "") || (aEvidence?.path ?? "").localeCompare(bEvidence?.path ?? "") || a.message.localeCompare(b.message);
+}
+function summarize2(findings, ruleCount) {
+  const failed = findings.filter((item) => item.status === "fail").length;
+  const warnings = findings.filter((item) => item.status === "warning").length;
+  const errors = findings.filter((item) => item.severity === "error").length;
+  return {
+    passed: Math.max(0, ruleCount - failed - warnings),
+    failed,
+    warnings,
+    errors
+  };
+}
+function defaultRules() {
+  return [checks.requireSuccess()];
+}
+async function evalRun(input3, options = {}) {
+  const resolved = await resolveRead(input3, options);
+  if (resolved.read === void 0) {
+    return errorResult3("unknown", resolved.diagnostics);
+  }
+  const selected = selectRun3(resolved.read, resolved.runId);
+  if (selected.run === void 0) {
+    return errorResult3(resolved.read.format, selected.diagnostics, resolved.runId);
+  }
+  const rules = [...options.checks ?? defaultRules()].sort(
+    (a, b) => a.id.localeCompare(b.id)
+  );
+  const context = {
+    format: resolved.read.format,
+    run: selected.run,
+    nodes: flatten2(selected.run.children),
+    events: resolved.read.events.filter((event) => event.runId === selected.run?.runId)
+  };
+  const diagnostics = [];
+  const findings = [];
+  for (const rule of rules) {
+    try {
+      findings.push(...rule.evaluate(context).map((finding) => normalizeFinding2(rule, finding)));
+    } catch (error) {
+      diagnostics.push({
+        code: "AI_EVAL_RULE_FAILED",
+        severity: "error",
+        ruleId: rule.id,
+        message: `Eval rule ${rule.id} failed: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  if (diagnostics.length > 0) {
+    return errorResult3(resolved.read.format, diagnostics, selected.run.runId);
+  }
+  const sortedFindings = findings.sort(compareFindings2);
+  const summary = summarize2(sortedFindings, rules.length);
+  const status = summary.failed > 0 ? "fail" : "pass";
+  return {
+    ok: status === "pass",
+    status,
+    format: resolved.read.format,
+    runId: selected.run.runId,
+    summary,
+    findings: sortedFindings,
+    diagnostics: []
+  };
+}
+function evidenceForRun(run, path15) {
+  return [{ runId: run.runId, ...path15 !== void 0 ? { path: path15 } : {} }];
+}
+function evidenceForEvent(event, path15) {
+  return [
+    {
+      runId: event.runId,
+      eventId: event.eventId,
+      ...event.parentId !== void 0 ? { parentId: event.parentId } : {},
+      kind: event.kind,
+      name: event.name,
+      ...path15 !== void 0 ? { path: path15 } : {}
+    }
+  ];
+}
+function fail(ruleId, message, evidence, expected, actual) {
+  return {
+    ruleId,
+    status: "fail",
+    severity: "error",
+    message,
+    ...expected !== void 0 ? { expected } : {},
+    ...actual !== void 0 ? { actual } : {},
+    evidence
+  };
+}
+function nodeNames(nodes, kind) {
+  return nodes.filter((node) => node.event.kind === kind).map((node) => node.event.name).sort((a, b) => a.localeCompare(b));
+}
+function hasAttribute(node, key) {
+  return node.event.attributes !== void 0 && Object.prototype.hasOwnProperty.call(node.event.attributes, key);
+}
+function numericAttribute(node, keys) {
+  const attrs = node.event.attributes;
+  if (attrs === void 0) return void 0;
+  for (const key of keys) {
+    const value = attrs[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function totalTokenCount(events) {
+  return events.reduce((total, event) => {
+    const usage = event.tokenUsage;
+    if (usage?.total !== void 0) return total + usage.total;
+    return total + (usage?.input ?? 0) + (usage?.output ?? 0);
+  }, 0);
+}
+function createRule(id, category, evaluate) {
+  return { id, category, severity: "error", evaluate };
+}
+var DEFAULT_ANSWER_KEYS = [
+  "answer",
+  "finalAnswer",
+  "final",
+  "response",
+  "result",
+  "output",
+  "outputPreview",
+  "completion",
+  "text"
+];
+var DEFAULT_CONTEXT_KEYS = [
+  "context",
+  "contexts",
+  "document",
+  "documents",
+  "retrieved",
+  "retrieval",
+  "chunks",
+  "chunk",
+  "source",
+  "sources",
+  "sourceText"
+];
+var DEFAULT_CITATION_KEYS = [
+  "citation",
+  "citations",
+  "reference",
+  "references",
+  "sourceId",
+  "sourceIds",
+  "source_id",
+  "source_ids"
+];
+var DEFAULT_SOURCE_ID_KEYS = [
+  ...DEFAULT_CITATION_KEYS,
+  "id",
+  "ids",
+  "documentId",
+  "documentIds",
+  "docId",
+  "docIds"
+];
+var DEFAULT_BANNED_UNSUPPORTED_PHRASES = [
+  "i don't have enough information",
+  "i do not have enough information",
+  "not enough context",
+  "cannot determine from the context",
+  "unable to determine from the provided context"
+];
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "but",
+  "for",
+  "from",
+  "have",
+  "into",
+  "not",
+  "that",
+  "the",
+  "their",
+  "this",
+  "was",
+  "were",
+  "with",
+  "you",
+  "your"
+]);
+function normalizeKey(key) {
+  return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function keySet(keys) {
+  return new Set(keys.map(normalizeKey));
+}
+function valuesAsStrings(value, depth = 0) {
+  if (depth > 5) return [];
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? [trimmed] : [];
+  }
+  if (typeof value === "number" || typeof value === "boolean") return [String(value)];
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => valuesAsStrings(item, depth + 1));
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.values(value).flatMap(
+      (item) => valuesAsStrings(item, depth + 1)
+    );
+  }
+  return [];
+}
+function collectTextFields(nodes, keys, preferredKinds = []) {
+  const wanted = keySet(keys);
+  const preferred = new Set(preferredKinds);
+  const orderedNodes = [...nodes].sort((a, b) => {
+    const aPreferred = preferred.has(a.event.kind) ? 0 : 1;
+    const bPreferred = preferred.has(b.event.kind) ? 0 : 1;
+    return aPreferred - bPreferred || a.event.eventId.localeCompare(b.event.eventId);
+  });
+  const fields = [];
+  for (const node of orderedNodes) {
+    const attrs = node.event.attributes;
+    if (attrs === void 0) continue;
+    for (const [key, value] of Object.entries(attrs)) {
+      if (!wanted.has(normalizeKey(key))) continue;
+      for (const text of valuesAsStrings(value)) {
+        fields.push({ text, node, path: `attributes.${key}` });
+      }
+    }
+  }
+  return fields;
+}
+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, path15) {
+  const first = fields[0];
+  return first === void 0 ? evidenceForRun(run, path15) : evidenceForEvent(first.node.event, first.path);
+}
+function collectSourceIds(nodes, keys) {
+  const wanted = keySet(keys);
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    const attrs = node.event.attributes;
+    if (attrs === void 0) continue;
+    for (const [key, value] of Object.entries(attrs)) {
+      if (!wanted.has(normalizeKey(key))) continue;
+      for (const candidate of valuesAsStrings(value)) {
+        const trimmed = candidate.trim();
+        if (trimmed.length > 0 && trimmed.length <= 128) ids.add(trimmed);
+      }
+    }
+  }
+  return [...ids].sort((a, b) => a.localeCompare(b));
+}
+function citationCount(answer, citationFields) {
+  const inline = answer.match(/\[[^\]\n]{1,40}\]|\([A-Za-z][A-Za-z0-9_-]{0,39}\)/g)?.length ?? 0;
+  return inline + citationFields.length;
+}
+function quotedSnippets(text, minLength) {
+  const snippets = /* @__PURE__ */ new Set();
+  const pattern = /"([^"\n]+)"|'([^'\n]+)'|“([^”\n]+)”/g;
+  for (const match of text.matchAll(pattern)) {
+    const snippet = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+    if (snippet.length >= minLength) snippets.add(snippet);
+  }
+  return [...snippets].sort((a, b) => a.localeCompare(b));
+}
+function wordCount(text) {
+  return tokenize(text).length;
+}
+var checks = {
+  requireSuccess() {
+    return createRule(
+      "eval.requireSuccess",
+      "run",
+      (context) => context.run.status === "ok" ? [] : [
+        fail(
+          "eval.requireSuccess",
+          "Run did not complete successfully.",
+          evidenceForRun(context.run, "status"),
+          "ok",
+          context.run.status ?? "unknown"
+        )
+      ]
+    );
+  },
+  requiredTools(required) {
+    const expected = [...required].sort((a, b) => a.localeCompare(b));
+    return createRule("eval.requiredTools", "tool", (context) => {
+      const tools = new Set(nodeNames(context.nodes, "TOOL"));
+      return expected.filter((name) => !tools.has(name)).map(
+        (name) => fail(
+          "eval.requiredTools",
+          `Required tool ${name} did not appear.`,
+          evidenceForRun(context.run, "children"),
+          name,
+          [...tools].sort((a, b) => a.localeCompare(b))
+        )
+      );
+    });
+  },
+  forbiddenTools(forbidden) {
+    const blocked = [...forbidden].sort((a, b) => a.localeCompare(b));
+    return createRule(
+      "eval.forbiddenTools",
+      "tool",
+      (context) => context.nodes.filter((node) => node.event.kind === "TOOL" && blocked.includes(node.event.name)).map(
+        (node) => fail(
+          "eval.forbiddenTools",
+          `Forbidden tool ${node.event.name} appeared.`,
+          evidenceForEvent(node.event, "name"),
+          "tool absent",
+          node.event.name
+        )
+      )
+    );
+  },
+  maxDurationMs(maxDurationMs) {
+    return createRule(
+      "eval.maxDurationMs",
+      "run",
+      (context) => context.run.durationMs !== void 0 && context.run.durationMs > maxDurationMs ? [
+        fail(
+          "eval.maxDurationMs",
+          `Run duration exceeded ${maxDurationMs}ms.`,
+          evidenceForRun(context.run, "durationMs"),
+          { maxDurationMs },
+          context.run.durationMs
+        )
+      ] : []
+    );
+  },
+  maxDepth(maxDepth) {
+    return createRule("eval.maxDepth", "structure", (context) => {
+      const deepest = context.nodes.reduce(
+        (current, node) => current === void 0 || node.depth > current.depth ? node : current,
+        void 0
+      );
+      return deepest !== void 0 && deepest.depth > maxDepth ? [
+        fail(
+          "eval.maxDepth",
+          `Run tree depth exceeded ${maxDepth}.`,
+          evidenceForEvent(deepest.event, "depth"),
+          { maxDepth },
+          deepest.depth
+        )
+      ] : [];
+    });
+  },
+  maxRetries(maxRetries) {
+    return createRule(
+      "eval.maxRetries",
+      "structure",
+      (context) => context.nodes.flatMap((node) => {
+        const retries = numericAttribute(node, ["retryCount", "retries", "attempt"]);
+        return retries !== void 0 && retries > maxRetries ? [
+          fail(
+            "eval.maxRetries",
+            `Retry count exceeded ${maxRetries}.`,
+            evidenceForEvent(node.event, "attributes.retryCount"),
+            { maxRetries },
+            retries
+          )
+        ] : [];
+      })
+    );
+  },
+  maxTotalTokens(maxTotalTokens) {
+    return createRule("eval.maxTotalTokens", "llm", (context) => {
+      const total = totalTokenCount(context.events);
+      return total > maxTotalTokens ? [
+        fail(
+          "eval.maxTotalTokens",
+          `Total token usage exceeded ${maxTotalTokens}.`,
+          evidenceForRun(context.run, "tokenUsage.total"),
+          { maxTotalTokens },
+          total
+        )
+      ] : [];
+    });
+  },
+  noFailedSteps() {
+    return createRule(
+      "eval.noFailedSteps",
+      "run",
+      (context) => context.nodes.filter((node) => node.event.status === "error" || node.event.kind === "ERROR").map(
+        (node) => fail(
+          "eval.noFailedSteps",
+          "Run contains a failed step or error node.",
+          evidenceForEvent(node.event, "status"),
+          "no failed nodes",
+          node.event.status ?? node.event.kind
+        )
+      )
+    );
+  },
+  requiredRetrievalBeforeGeneration() {
+    return createRule("eval.requiredRetrievalBeforeGeneration", "retrieval", (context) => {
+      const firstLlmIndex = context.nodes.findIndex((node) => node.event.kind === "LLM");
+      if (firstLlmIndex === -1) return [];
+      const retrievalIndex = context.nodes.findIndex(
+        (node, index) => index < firstLlmIndex && node.event.kind === "RETRIEVER"
+      );
+      return retrievalIndex === -1 ? [
+        fail(
+          "eval.requiredRetrievalBeforeGeneration",
+          "No retrieval step appeared before the first LLM generation.",
+          evidenceForEvent(context.nodes[firstLlmIndex].event, "kind"),
+          "RETRIEVER before LLM",
+          "LLM before RETRIEVER"
+        )
+      ] : [];
+    });
+  },
+  requiredDecisionMetadata(keys) {
+    const required = [...keys].sort((a, b) => a.localeCompare(b));
+    return createRule("eval.requiredDecisionMetadata", "structure", (context) => {
+      const decisions = context.nodes.filter((node) => node.event.kind === "DECISION");
+      if (decisions.length === 0) {
+        return [
+          fail(
+            "eval.requiredDecisionMetadata",
+            "No decision node is available for required metadata.",
+            evidenceForRun(context.run, "children"),
+            { decisionMetadata: required },
+            "no decision nodes"
+          )
+        ];
+      }
+      return decisions.flatMap(
+        (node) => required.filter((key) => !hasAttribute(node, key)).map(
+          (key) => fail(
+            "eval.requiredDecisionMetadata",
+            `Decision metadata ${key} is missing.`,
+            evidenceForEvent(node.event, `attributes.${key}`),
+            key,
+            "missing"
+          )
+        )
+      );
+    });
+  },
+  contextOverlap(options = {}) {
+    const minOverlap = options.minOverlap ?? 0.1;
+    const minSharedTerms = options.minSharedTerms ?? 1;
+    const answerKeys = options.answerKeys ?? DEFAULT_ANSWER_KEYS;
+    const contextKeys = options.contextKeys ?? DEFAULT_CONTEXT_KEYS;
+    return createRule("eval.contextOverlap", "retrieval", (context) => {
+      const answers = collectTextFields(context.nodes, answerKeys, ["RESULT", "LLM", "AGENT"]);
+      const contexts = collectTextFields(context.nodes, contextKeys, ["RETRIEVER", "TOOL"]);
+      if (answers.length === 0 || contexts.length === 0) {
+        return [
+          fail(
+            "eval.contextOverlap",
+            "Answer and context text are required for overlap evaluation.",
+            firstEvidence(answers.length > 0 ? answers : contexts, context.run, "children"),
+            { answer: "present", context: "present" },
+            { answerFields: answers.length, contextFields: contexts.length }
+          )
+        ];
+      }
+      const answerTerms = new Set(tokenize(answers.map((field) => field.text).join(" ")));
+      const contextTerms = new Set(tokenize(contexts.map((field) => field.text).join(" ")));
+      const sharedTerms = [...answerTerms].filter((term) => contextTerms.has(term)).length;
+      const overlap = answerTerms.size === 0 ? 0 : sharedTerms / answerTerms.size;
+      return sharedTerms < minSharedTerms || overlap < minOverlap ? [
+        fail(
+          "eval.contextOverlap",
+          "Answer text did not sufficiently overlap retrieved context.",
+          firstEvidence(answers, context.run, "attributes.answer"),
+          { minOverlap, minSharedTerms },
+          {
+            answerTerms: answerTerms.size,
+            contextTerms: contextTerms.size,
+            sharedTerms,
+            overlap: Number(overlap.toFixed(4))
+          }
+        )
+      ] : [];
+    });
+  },
+  quoteOverlap(options = {}) {
+    const answerKeys = options.answerKeys ?? DEFAULT_ANSWER_KEYS;
+    const contextKeys = options.contextKeys ?? DEFAULT_CONTEXT_KEYS;
+    const minQuoteLength = options.minQuoteLength ?? 6;
+    const requireQuote = options.requireQuote ?? true;
+    return createRule("eval.quoteOverlap", "retrieval", (context) => {
+      const answers = collectTextFields(context.nodes, answerKeys, ["RESULT", "LLM", "AGENT"]);
+      const contexts = collectTextFields(context.nodes, contextKeys, ["RETRIEVER", "TOOL"]);
+      const answerText = answers.map((field) => field.text).join(" ");
+      const contextText = contexts.map((field) => field.text).join(" ").toLowerCase();
+      const quotes = quotedSnippets(answerText, minQuoteLength);
+      if (quotes.length === 0) {
+        return requireQuote ? [
+          fail(
+            "eval.quoteOverlap",
+            "Answer did not contain a quote for overlap evaluation.",
+            firstEvidence(answers, context.run, "attributes.answer"),
+            { quotedText: "present" },
+            { quoteCount: 0 }
+          )
+        ] : [];
+      }
+      const missing = quotes.filter((quote) => !contextText.includes(quote.toLowerCase()));
+      return missing.length > 0 ? [
+        fail(
+          "eval.quoteOverlap",
+          "Quoted answer text did not appear in retrieved context.",
+          firstEvidence(answers, context.run, "attributes.answer"),
+          { allQuotesInContext: true },
+          { quoteCount: quotes.length, missingQuotes: missing.length }
+        )
+      ] : [];
+    });
+  },
+  citationPresence(options = {}) {
+    const answerKeys = options.answerKeys ?? DEFAULT_ANSWER_KEYS;
+    const citationKeys = options.citationKeys ?? DEFAULT_CITATION_KEYS;
+    return createRule("eval.citationPresence", "retrieval", (context) => {
+      const answers = collectTextFields(context.nodes, answerKeys, ["RESULT", "LLM", "AGENT"]);
+      const citations = collectTextFields(context.nodes, citationKeys);
+      const count = citationCount(answers.map((field) => field.text).join(" "), citations);
+      return count === 0 ? [
+        fail(
+          "eval.citationPresence",
+          "Answer did not include citations or source references.",
+          firstEvidence(answers, context.run, "attributes.answer"),
+          { citationCount: ">= 1" },
+          { citationCount: 0 }
+        )
+      ] : [];
+    });
+  },
+  requiredSourceIds(requiredIds, options = {}) {
+    const expected = [...requiredIds].sort((a, b) => a.localeCompare(b));
+    const sourceIdKeys = options.sourceIdKeys ?? DEFAULT_SOURCE_ID_KEYS;
+    return createRule("eval.requiredSourceIds", "retrieval", (context) => {
+      const available = collectSourceIds(context.nodes, sourceIdKeys);
+      const availableSet = new Set(available);
+      const missing = expected.filter((id) => !availableSet.has(id));
+      return missing.length > 0 ? [
+        fail(
+          "eval.requiredSourceIds",
+          "Required source IDs were not present in trace context or citations.",
+          evidenceForRun(context.run, "children"),
+          { sourceIds: expected },
+          { missingSourceIds: missing, availableSourceIds: available.slice(0, 20) }
+        )
+      ] : [];
+    });
+  },
+  answerLengthBounds(options) {
+    const answerKeys = options.answerKeys ?? DEFAULT_ANSWER_KEYS;
+    return createRule("eval.answerLengthBounds", "llm", (context) => {
+      const answers = collectTextFields(context.nodes, answerKeys, ["RESULT", "LLM", "AGENT"]);
+      const answer = answers.map((field) => field.text).join(" ").trim();
+      const characters = answer.length;
+      const words = wordCount(answer);
+      const tooShort = options.minCharacters !== void 0 && characters < options.minCharacters || options.minWords !== void 0 && words < options.minWords;
+      const tooLong = options.maxCharacters !== void 0 && characters > options.maxCharacters || options.maxWords !== void 0 && words > options.maxWords;
+      return answer.length === 0 || tooShort || tooLong ? [
+        fail(
+          "eval.answerLengthBounds",
+          "Answer length fell outside required bounds.",
+          firstEvidence(answers, context.run, "attributes.answer"),
+          {
+            minCharacters: options.minCharacters,
+            maxCharacters: options.maxCharacters,
+            minWords: options.minWords,
+            maxWords: options.maxWords
+          },
+          { characters, words }
+        )
+      ] : [];
+    });
+  },
+  bannedUnsupportedPhrases(phrases = DEFAULT_BANNED_UNSUPPORTED_PHRASES, options = {}) {
+    const answerKeys = options.answerKeys ?? DEFAULT_ANSWER_KEYS;
+    const banned = [...phrases].map((phrase) => phrase.toLowerCase()).sort();
+    return createRule("eval.bannedUnsupportedPhrases", "safety", (context) => {
+      const answers = collectTextFields(context.nodes, answerKeys, ["RESULT", "LLM", "AGENT"]);
+      const answer = answers.map((field) => field.text).join(" ").toLowerCase();
+      const matches = banned.filter((phrase) => answer.includes(phrase));
+      return matches.length > 0 ? [
+        fail(
+          "eval.bannedUnsupportedPhrases",
+          "Answer contained banned unsupported-answer phrasing.",
+          firstEvidence(answers, context.run, "attributes.answer"),
+          { bannedPhraseCount: banned.length },
+          { matchedPhraseCount: matches.length }
+        )
+      ] : [];
+    });
+  }
+};
+function renderEvalMarkdown(result) {
+  const lines = [
+    `# AgentInspect Eval`,
+    "",
+    `Status: ${result.status}`,
+    `Format: ${result.format}`,
+    ...result.runId !== void 0 ? [`Run: ${result.runId}`] : [],
+    `Summary: ${result.summary.passed} passed, ${result.summary.failed} failed, ${result.summary.warnings} warnings, ${result.summary.errors} errors`
+  ];
+  if (result.diagnostics.length > 0) {
+    lines.push("", "## Diagnostics");
+    for (const diagnostic4 of result.diagnostics) {
+      lines.push(`- ${diagnostic4.code}: ${diagnostic4.message}`);
+    }
+  }
+  if (result.findings.length > 0) {
+    lines.push("", "## Findings");
+    for (const finding of result.findings) {
+      const path15 = finding.evidence[0]?.path;
+      lines.push(`- ${finding.ruleId}: ${finding.message}${path15 ? ` (${path15})` : ""}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// packages/cli/src/eval.ts
+var CONFIG_EXTENSIONS2 = /* @__PURE__ */ new Set([".json", ".js", ".mjs", ".cjs"]);
+var TS_CONFIG_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".mts", ".cts"]);
+function diagnostic3(code, message, severity = "error") {
+  return { code, message, severity };
+}
+function errorResult4(code, message, format = "unknown") {
+  return {
+    ok: false,
+    status: "error",
+    format,
+    summary: { passed: 0, failed: 0, warnings: 0, errors: 1 },
+    findings: [],
+    diagnostics: [diagnostic3(code, message)]
+  };
+}
+function parseNumber2(value, label) {
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`${label} must be a non-negative number.`);
+  }
+  return parsed;
+}
+function asStringArray2(value, label) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${label} must be an array of strings.`);
+  }
+  return value;
+}
+function asConfig2(value) {
+  if (value === void 0 || value === null) return {};
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Config must export an object.");
+  }
+  return value;
+}
+async function loadConfig2(configPath) {
+  if (configPath === void 0) return {};
+  const extension = path13.extname(configPath);
+  if (TS_CONFIG_EXTENSIONS2.has(extension)) {
+    throw new Error(
+      "TypeScript eval configs require an explicit precompiled JavaScript config or future --config-loader support."
+    );
+  }
+  if (!CONFIG_EXTENSIONS2.has(extension)) {
+    throw new Error("Unsupported eval config extension. Use .json, .js, .mjs, or .cjs.");
+  }
+  const absolute = path13.resolve(configPath);
+  if (extension === ".json") {
+    const raw = await readFile(absolute, "utf-8");
+    return asConfig2(JSON.parse(raw));
+  }
+  const mod = await import(pathToFileURL(absolute).href);
+  return asConfig2("default" in mod ? mod.default : mod);
+}
+function normalizeConfig2(config) {
+  if (config.eval === void 0) return {};
+  if (typeof config.eval !== "object" || Array.isArray(config.eval)) {
+    throw new Error("eval config must be an object.");
+  }
+  return config.eval;
+}
+function maybeAdd(rules, value, makeRule) {
+  if (value !== void 0) rules.push(makeRule(value));
+}
+function optionObject(value) {
+  if (value === void 0 || value === false) return void 0;
+  if (value === true) return {};
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Eval heuristic config must be a boolean or object.");
+  }
+  return value;
+}
+function sourceIdsFromConfig(value) {
+  if (value === void 0) return void 0;
+  if (Array.isArray(value)) return { ids: asStringArray2(value, "eval.requiredSourceIds") ?? [] };
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("eval.requiredSourceIds must be an array or object.");
+  }
+  const ids = asStringArray2(value.ids, "eval.requiredSourceIds.ids") ?? [];
+  return { ids, options: { sourceIdKeys: value.sourceIdKeys } };
+}
+function buildRules2(config, options) {
+  const evalConfig = normalizeConfig2(config);
+  const rules = [];
+  if (evalConfig.requireSuccess || options.requireSuccess) rules.push(checks.requireSuccess());
+  const requiredTools = [
+    ...asStringArray2(evalConfig.requiredTools, "eval.requiredTools") ?? [],
+    ...options.requiredTool ?? []
+  ];
+  if (requiredTools.length > 0) rules.push(checks.requiredTools(requiredTools));
+  const forbiddenTools = [
+    ...asStringArray2(evalConfig.forbiddenTools, "eval.forbiddenTools") ?? [],
+    ...options.forbidTool ?? [],
+    ...options.forbiddenTool ?? []
+  ];
+  if (forbiddenTools.length > 0) rules.push(checks.forbiddenTools(forbiddenTools));
+  const maxDurationMs = parseNumber2(options.maxDurationMs, "--max-duration-ms") ?? evalConfig.maxDurationMs;
+  maybeAdd(rules, maxDurationMs, checks.maxDurationMs);
+  const maxDepth = parseNumber2(options.maxDepth, "--max-depth") ?? evalConfig.maxDepth;
+  maybeAdd(rules, maxDepth, checks.maxDepth);
+  const maxRetries = parseNumber2(options.maxRetries, "--max-retries") ?? evalConfig.maxRetries;
+  maybeAdd(rules, maxRetries, checks.maxRetries);
+  const maxTotalTokens = parseNumber2(options.maxTotalTokens, "--max-total-tokens") ?? evalConfig.maxTotalTokens;
+  maybeAdd(rules, maxTotalTokens, checks.maxTotalTokens);
+  if (evalConfig.requiredRetrievalBeforeGeneration || options.requireRetrievalBeforeGeneration) {
+    rules.push(checks.requiredRetrievalBeforeGeneration());
+  }
+  const requiredDecisionMetadata = [
+    ...asStringArray2(
+      evalConfig.requiredDecisionMetadata,
+      "eval.requiredDecisionMetadata"
+    ) ?? [],
+    ...options.requiredDecisionMetadata ?? []
+  ];
+  if (requiredDecisionMetadata.length > 0) {
+    rules.push(checks.requiredDecisionMetadata(requiredDecisionMetadata));
+  }
+  const contextOverlap = optionObject(evalConfig.contextOverlap);
+  const minOverlap = parseNumber2(options.minContextOverlap, "--min-context-overlap");
+  const minSharedTerms = parseNumber2(options.minSharedTerms, "--min-shared-terms");
+  if (contextOverlap !== void 0 || options.contextOverlap || minOverlap !== void 0 || minSharedTerms !== void 0) {
+    rules.push(checks.contextOverlap({ ...contextOverlap, minOverlap, minSharedTerms }));
+  }
+  const quoteOverlap = optionObject(evalConfig.quoteOverlap);
+  if (quoteOverlap !== void 0 || options.quoteOverlap) {
+    rules.push(checks.quoteOverlap(quoteOverlap));
+  }
+  const citationPresence = optionObject(evalConfig.citationPresence);
+  if (citationPresence !== void 0 || options.citationPresence) {
+    rules.push(checks.citationPresence(citationPresence));
+  }
+  const sourceIds = sourceIdsFromConfig(evalConfig.requiredSourceIds);
+  const requiredSourceIds = [...sourceIds?.ids ?? [], ...options.requiredSourceId ?? []];
+  if (requiredSourceIds.length > 0) {
+    rules.push(checks.requiredSourceIds(requiredSourceIds, sourceIds?.options));
+  }
+  const cliAnswerLength = {
+    minCharacters: parseNumber2(options.minAnswerCharacters, "--min-answer-characters"),
+    maxCharacters: parseNumber2(options.maxAnswerCharacters, "--max-answer-characters"),
+    minWords: parseNumber2(options.minAnswerWords, "--min-answer-words"),
+    maxWords: parseNumber2(options.maxAnswerWords, "--max-answer-words")
+  };
+  const hasCliAnswerLength = Object.values(cliAnswerLength).some((value) => value !== void 0);
+  if (evalConfig.answerLengthBounds !== void 0 || hasCliAnswerLength) {
+    rules.push(checks.answerLengthBounds({ ...evalConfig.answerLengthBounds, ...cliAnswerLength }));
+  }
+  const bannedPhrases = [
+    ...asStringArray2(
+      evalConfig.bannedUnsupportedPhrases,
+      "eval.bannedUnsupportedPhrases"
+    ) ?? [],
+    ...options.bannedPhrase ?? []
+  ];
+  if (bannedPhrases.length > 0) rules.push(checks.bannedUnsupportedPhrases(bannedPhrases));
+  return rules.length > 0 ? rules : void 0;
+}
+function exitCodeFor2(result) {
+  if (result.status === "pass") return 0;
+  if (result.status === "fail") return 1;
+  return 2;
+}
+function stable3(value) {
+  if (Array.isArray(value)) return value.map(stable3);
+  if (value === null || typeof value !== "object") return value;
+  const record = value;
+  return Object.fromEntries(
+    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable3(record[key])])
+  );
+}
+function printJson2(result) {
+  console.log(JSON.stringify(stable3(result), null, 2));
+}
+function printHuman2(result) {
+  console.log(`Eval status: ${result.status}`);
+  console.log(`Format: ${result.format}`);
+  if (result.runId !== void 0) console.log(`Run: ${result.runId}`);
+  console.log(
+    `Summary: ${result.summary.failed} failed, ${result.summary.warnings} warning(s), ${result.summary.errors} error(s)`
+  );
+  for (const diagnostic4 of result.diagnostics) {
+    console.log(`- ${diagnostic4.code}: ${diagnostic4.message}`);
+  }
+  for (const finding of result.findings) {
+    const path15 = finding.evidence[0]?.path;
+    console.log(`- ${finding.ruleId}: ${finding.message}${path15 ? ` (${path15})` : ""}`);
+  }
+}
+function readErrorResult2(error) {
+  if (error instanceof TraceReadError) {
+    const code = error.code === "unsupported_format" ? "AI_EVAL_UNSUPPORTED_FORMAT" : error.code === "ambiguous_format" ? "AI_EVAL_AMBIGUOUS_FORMAT" : "AI_EVAL_TRACE_UNREADABLE";
+    return errorResult4(code, error.message);
+  }
+  return errorResult4(
+    "AI_EVAL_TRACE_UNREADABLE",
+    error instanceof Error ? error.message : String(error)
+  );
+}
+async function evalCommand(target, options = {}, stdin = process.stdin) {
+  let result;
+  let phase = "config";
+  try {
+    const config = await loadConfig2(options.config);
+    const rules = buildRules2(config, options);
+    phase = "read";
+    const input3 = await inputFromTarget(target, options, stdin);
+    const read = await openTrace(input3, {
+      ...options.format !== void 0 ? { format: options.format } : {}
+    });
+    result = await evalRun(read, {
+      ...rules !== void 0 ? { checks: rules } : {},
+      ...options.run !== void 0 ? { runId: options.run } : {}
+    });
+  } catch (error) {
+    if (phase === "config") {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = message.startsWith("--") ? "AI_EVAL_INVALID_ARGUMENTS" : error instanceof SyntaxError || message.includes("Unsupported eval config extension") || message.includes("TypeScript eval configs") || message.includes("Config must") || message.includes("eval config") || message.includes("must be an array") ? "AI_EVAL_INVALID_CONFIG" : "AI_EVAL_CONFIG_LOAD_FAILED";
+      result = errorResult4(code, message);
+    } else {
+      result = readErrorResult2(error);
+    }
+  }
+  process.exitCode = exitCodeFor2(result);
+  if (options.json) printJson2(result);
+  else if (options.markdown) console.log(renderEvalMarkdown(result).trimEnd());
+  else printHuman2(result);
+}
+
+// packages/cli/src/safety.ts
+var BEST_EFFORT_NOTE = "Best-effort local safety verification only; not a compliance, privacy, security, or regulatory certification.";
+var DEFAULT_MAX_STRING_LENGTH = 16384;
+var DEFAULT_MAX_ARRAY_LENGTH = 1e3;
+var DEFAULT_MAX_OBJECT_KEYS = 200;
+var DEFAULT_MAX_SERIALIZED_BYTES = 128 * 1024;
+function parseLimit3(value, label) {
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`${label} must be a non-negative number.`);
+  }
+  return parsed;
+}
+function stable4(value) {
+  if (Array.isArray(value)) return value.map(stable4);
+  if (value === null || typeof value !== "object") return value;
+  const record = value;
+  return Object.fromEntries(
+    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable4(record[key])])
+  );
+}
+function safetyDiagnostic(code, message, severity = "error") {
+  return { code, message, severity };
+}
+function warningDiagnostics(warnings, unsupportedFields) {
+  return [
+    ...warnings.map(
+      (warning) => safetyDiagnostic(
+        warning.code,
+        warning.message,
+        warning.severity === "error" ? "error" : "warning"
+      )
+    ),
+    ...unsupportedFields.map(
+      (field) => safetyDiagnostic(
         "unsupported_field",
         `Reader reported unsupported field: ${field}`,
         "warning"
@@ -10596,7 +12038,7 @@ function resultFromParts(parts) {
     note: BEST_EFFORT_NOTE
   };
 }
-function readErrorResult2(command, error) {
+function readErrorResult3(command, error) {
   if (error instanceof TraceReadError) {
     const code = error.code === "unsupported_format" ? "AI_SAFETY_UNSUPPORTED_FORMAT" : error.code === "ambiguous_format" ? "AI_SAFETY_AMBIGUOUS_FORMAT" : "AI_SAFETY_TRACE_UNREADABLE";
     return resultFromParts({
@@ -10646,27 +12088,76 @@ function buildSafetyRules(options) {
     })
   ];
 }
-function exitCodeFor2(result) {
+function flattenNodes2(nodes) {
+  return nodes.flatMap((node) => [
+    node,
+    ...flattenNodes2(
+      node.children
+    )
+  ]);
+}
+function detectorSeverity(finding) {
+  return finding.severity;
+}
+function redactionDetectorFindings(read, runId) {
+  const runs = runId === void 0 ? read.runs : read.runs.filter((run) => run.runId === runId);
+  const out = [];
+  for (const run of runs) {
+    for (const node of flattenNodes2(run.children)) {
+      const attrs = node.event.attributes;
+      if (attrs === void 0) continue;
+      const result = redact(attrs, { profile: "share" });
+      for (const finding of result.findings) {
+        if (finding.action === "keep") continue;
+        out.push({
+          ruleId: "safety.redactDetector",
+          severity: detectorSeverity(finding),
+          status: finding.severity === "error" ? "fail" : "warning",
+          message: `Redaction detector ${finding.detector} matched ${finding.matchKind} at ${finding.path}.`,
+          expected: "redacted trace content",
+          actual: finding.detector,
+          evidence: [
+            {
+              runId: node.event.runId,
+              eventId: node.event.eventId,
+              ...node.event.parentId !== void 0 ? { parentId: node.event.parentId } : {},
+              kind: node.event.kind,
+              name: node.event.name,
+              ...node.event.status !== void 0 ? { status: node.event.status } : {},
+              path: `attributes.${finding.path.replace(/^\$\.?/, "")}`
+            }
+          ]
+        });
+      }
+    }
+  }
+  return out.sort((a, b) => {
+    const aEvidence = a.evidence[0];
+    const bEvidence = b.evidence[0];
+    return (aEvidence?.runId ?? "").localeCompare(bEvidence?.runId ?? "") || (aEvidence?.eventId ?? "").localeCompare(bEvidence?.eventId ?? "") || (aEvidence?.path ?? "").localeCompare(bEvidence?.path ?? "") || a.message.localeCompare(b.message);
+  });
+}
+function exitCodeFor3(result) {
   if (result.status === "SAFE" || result.status === "SAFE WITH WARNINGS") return 0;
   if (result.status === "UNSAFE") return 1;
   return 2;
 }
-function printJson2(result) {
-  console.log(JSON.stringify(stable2(result), null, 2));
+function printJson3(result) {
+  console.log(JSON.stringify(stable4(result), null, 2));
 }
-function printHuman2(result) {
+function printHuman3(result) {
   console.log(`Safety status: ${result.status}`);
   console.log(`Format: ${result.format}`);
   if (result.runId !== void 0) console.log(`Run: ${result.runId}`);
   console.log(
     `Summary: ${result.summary.findings} finding(s), ${result.summary.warnings} warning(s), ${result.summary.errors} error(s)`
   );
-  for (const diagnostic3 of result.diagnostics) {
-    console.log(`- ${diagnostic3.code}: ${diagnostic3.message}`);
+  for (const diagnostic4 of result.diagnostics) {
+    console.log(`- ${diagnostic4.code}: ${diagnostic4.message}`);
   }
   for (const finding of result.findings) {
-    const path12 = finding.evidence[0]?.path;
-    console.log(`- ${finding.ruleId}: ${finding.message}${path12 ? ` (${path12})` : ""}`);
+    const path15 = finding.evidence[0]?.path;
+    console.log(`- ${finding.ruleId}: ${finding.message}${path15 ? ` (${path15})` : ""}`);
   }
   console.log(`Note: ${result.note}`);
 }
@@ -10685,11 +12176,12 @@ async function safetyCommand(command, target, options, stdin) {
         ...options.run !== void 0 ? { runId: options.run } : {}
       }
     );
+    const detectorFindings = checkResult.diagnostics.length === 0 ? redactionDetectorFindings(read, checkResult.runId) : [];
     result = resultFromParts({
       command,
       format: checkResult.format,
       runId: checkResult.runId,
-      findings: checkResult.findings,
+      findings: [...checkResult.findings, ...detectorFindings],
       diagnostics: [
         ...checkResult.diagnostics.map(diagnosticFromCheck),
         ...warningDiagnostics(read.warnings, read.unsupportedFields)
@@ -10699,11 +12191,11 @@ async function safetyCommand(command, target, options, stdin) {
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    result = message.startsWith("--") ? invalidArgumentResult(command, error) : readErrorResult2(command, error);
+    result = message.startsWith("--") ? invalidArgumentResult(command, error) : readErrorResult3(command, error);
   }
-  process.exitCode = exitCodeFor2(result);
-  if (options.json) printJson2(result);
-  else printHuman2(result);
+  process.exitCode = exitCodeFor3(result);
+  if (options.json) printJson3(result);
+  else printHuman3(result);
 }
 function scanCommand(target, options = {}, stdin = process.stdin) {
   return safetyCommand("scan", target, options, stdin);
@@ -10723,16 +12215,16 @@ var SAFETY_RULES = [
     maxSerializedBytes: 128 * 1024
   })
 ];
-function stable3(value) {
-  if (Array.isArray(value)) return value.map(stable3);
+function stable5(value) {
+  if (Array.isArray(value)) return value.map(stable5);
   if (value === null || typeof value !== "object") return value;
   const record = value;
   return Object.fromEntries(
-    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable3(record[key])])
+    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable5(record[key])])
   );
 }
 function writeJson3(value) {
-  return `${JSON.stringify(stable3(value), null, 2)}
+  return `${JSON.stringify(stable5(value), null, 2)}
 `;
 }
 function escapeHtml2(value) {
@@ -10749,7 +12241,7 @@ function increment(record, key) {
   const label = key && key.trim() !== "" ? key : "unknown";
   record[label] = (record[label] ?? 0) + 1;
 }
-function selectRun3(read, runId) {
+function selectRun4(read, runId) {
   if (runId !== void 0) {
     return read.runs.find((run) => run.runId === runId);
   }
@@ -10784,11 +12276,11 @@ function renderCheckSection(result) {
     `Diagnostics: ${result.diagnostics.length}`
   ];
   for (const finding of result.findings.slice(0, 10)) {
-    const path12 = finding.evidence[0]?.path ?? "(run)";
-    lines.push(`- ${finding.ruleId}: ${finding.message} (${path12})`);
+    const path15 = finding.evidence[0]?.path ?? "(run)";
+    lines.push(`- ${finding.ruleId}: ${finding.message} (${path15})`);
   }
-  for (const diagnostic3 of result.diagnostics.slice(0, 10)) {
-    lines.push(`- ${diagnostic3.code}: ${diagnostic3.message}`);
+  for (const diagnostic4 of result.diagnostics.slice(0, 10)) {
+    lines.push(`- ${diagnostic4.code}: ${diagnostic4.message}`);
   }
   return lines.join("\n");
 }
@@ -10863,8 +12355,8 @@ function renderHtml(trace, check, diff) {
 `;
 }
 async function writeArtifact(outputDir, relativePath, content, files) {
-  const outPath = path10.join(outputDir, relativePath);
-  await mkdir(path10.dirname(outPath), { recursive: true });
+  const outPath = path13.join(outputDir, relativePath);
+  await mkdir(path13.dirname(outPath), { recursive: true });
   await writeFile(outPath, content, "utf-8");
   files.push(relativePath);
 }
@@ -10880,7 +12372,7 @@ function manifestStatus(check, diff) {
   return "ok";
 }
 async function artifactsCommand(target, options = {}, stdin = process.stdin) {
-  const outputDir = options.outputDir !== void 0 && options.outputDir.trim() !== "" ? path10.resolve(options.outputDir.trim()) : "";
+  const outputDir = options.outputDir !== void 0 && options.outputDir.trim() !== "" ? path13.resolve(options.outputDir.trim()) : "";
   if (outputDir === "") {
     console.error("--output-dir is required.");
     process.exitCode = 1;
@@ -10897,7 +12389,7 @@ async function artifactsCommand(target, options = {}, stdin = process.stdin) {
     process.exitCode = 1;
     return;
   }
-  const selectedRun = selectRun3(read, options.run);
+  const selectedRun = selectRun4(read, options.run);
   const check = runTraceChecks(
     { read },
     {
@@ -10946,8 +12438,8 @@ async function artifactsCommand(target, options = {}, stdin = process.stdin) {
   await writeArtifact(outputDir, "report.html", renderHtml(trace, check, diff), files);
   const summaryTarget = options.githubSummary ?? process.env.GITHUB_STEP_SUMMARY;
   if (summaryTarget !== void 0 && summaryTarget.trim() !== "") {
-    await mkdir(path10.dirname(path10.resolve(summaryTarget)), { recursive: true });
-    await appendFile(path10.resolve(summaryTarget), `
+    await mkdir(path13.dirname(path13.resolve(summaryTarget)), { recursive: true });
+    await appendFile(path13.resolve(summaryTarget), `
 ${renderMarkdown(trace, check, diff)}`, "utf-8");
   }
   const manifestFiles = [...files, "manifest.json"].sort((a, b) => a.localeCompare(b));
@@ -10966,10 +12458,10 @@ ${renderMarkdown(trace, check, diff)}`, "utf-8");
       findings: diff?.findings.length ?? 0,
       diagnostics: diff?.diagnostics.length ?? 0
     },
-    ...summaryTarget !== void 0 && summaryTarget.trim() !== "" ? { githubSummary: path10.resolve(summaryTarget) } : {},
+    ...summaryTarget !== void 0 && summaryTarget.trim() !== "" ? { githubSummary: path13.resolve(summaryTarget) } : {},
     note: NOTE
   };
-  await writeFile(path10.join(outputDir, "manifest.json"), writeJson3(manifest), "utf-8");
+  await writeFile(path13.join(outputDir, "manifest.json"), writeJson3(manifest), "utf-8");
   if (options.json === true) {
     console.log(writeJson3(manifest).trimEnd());
   } else {
@@ -10980,6 +12472,371 @@ ${renderMarkdown(trace, check, diff)}`, "utf-8");
     }
   }
 }
+function validateReporterArtifactPath(options) {
+  const outputDir = path13.resolve(options.outputDir);
+  const diagnostics = [];
+  const rawPath = options.relativePath;
+  if (rawPath.length === 0) {
+    diagnostics.push({
+      code: "artifact_path_empty",
+      severity: "error",
+      message: "Reporter artifact path must not be empty."
+    });
+    return { ok: false, outputDir, diagnostics };
+  }
+  if (rawPath.includes("\0")) {
+    diagnostics.push({
+      code: "invalid_artifact_path",
+      severity: "error",
+      message: "Reporter artifact path must not contain null bytes.",
+      target: rawPath
+    });
+    return { ok: false, outputDir, diagnostics };
+  }
+  if (path13.isAbsolute(rawPath) || path13.win32.isAbsolute(rawPath)) {
+    diagnostics.push({
+      code: "artifact_path_absolute",
+      severity: "error",
+      message: "Reporter artifact path must be relative.",
+      target: rawPath
+    });
+    return { ok: false, outputDir, diagnostics };
+  }
+  const normalized = path13.posix.normalize(rawPath.replace(/\\/g, "/"));
+  const segments = normalized.split("/");
+  if (normalized === "." || normalized.startsWith("../") || segments.some((segment) => segment === "..")) {
+    diagnostics.push({
+      code: "artifact_path_escape",
+      severity: "error",
+      message: "Reporter artifact path must stay under the output directory.",
+      target: rawPath
+    });
+    return { ok: false, outputDir, diagnostics };
+  }
+  const absolutePath = path13.resolve(outputDir, normalized);
+  const relFromOutput = path13.relative(outputDir, absolutePath);
+  if (relFromOutput.length === 0 || relFromOutput.startsWith("..") || path13.isAbsolute(relFromOutput)) {
+    diagnostics.push({
+      code: "artifact_path_escape",
+      severity: "error",
+      message: "Reporter artifact path resolved outside the output directory.",
+      target: rawPath
+    });
+    return { ok: false, outputDir, diagnostics };
+  }
+  return {
+    ok: true,
+    outputDir,
+    relativePath: normalized,
+    absolutePath,
+    diagnostics
+  };
+}
+
+// packages/cli/src/ci-summary.ts
+var NOTE2 = "Generated locally by AgentInspect from reporter artifact manifests. Trace contents are not embedded.";
+var MAX_TEXT = 180;
+var FRAMEWORKS = /* @__PURE__ */ new Set(["vitest", "jest", "manual"]);
+var STATUSES = /* @__PURE__ */ new Set(["passed", "failed", "skipped", "todo"]);
+var ARTIFACT_KINDS = /* @__PURE__ */ new Set(["trace", "report", "eval", "redaction", "summary"]);
+var ARTIFACT_FORMATS = /* @__PURE__ */ new Set(["json", "jsonl", "md", "html"]);
+var REDACTION_PROFILES = /* @__PURE__ */ new Set(["local", "share", "strict"]);
+function stable6(value) {
+  if (Array.isArray(value)) return value.map(stable6);
+  if (value === null || typeof value !== "object") return value;
+  const record = value;
+  return Object.fromEntries(
+    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable6(record[key])])
+  );
+}
+function writeJson4(value) {
+  return `${JSON.stringify(stable6(value), null, 2)}
+`;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value, label) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  return safeText(value);
+}
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim() !== "" ? safeText(value) : void 0;
+}
+function readFramework(value) {
+  const framework = readString(value, "manifest.framework");
+  if (!FRAMEWORKS.has(framework)) {
+    throw new Error(`Unsupported reporter framework: ${framework}.`);
+  }
+  return framework;
+}
+function readStatus(value) {
+  const status = readString(value, "result.status");
+  if (!STATUSES.has(status)) {
+    throw new Error(`Unsupported reporter test status: ${status}.`);
+  }
+  return status;
+}
+function readArtifact(value, index) {
+  if (!isObject(value)) throw new Error(`manifest.artifacts[${index}] must be an object.`);
+  const kind = readString(value.kind, `manifest.artifacts[${index}].kind`);
+  const format = readString(value.format, `manifest.artifacts[${index}].format`);
+  const redactionProfile = readString(
+    value.redactionProfile,
+    `manifest.artifacts[${index}].redactionProfile`
+  );
+  if (!ARTIFACT_KINDS.has(kind)) throw new Error(`Unsupported artifact kind: ${kind}.`);
+  if (!ARTIFACT_FORMATS.has(format)) throw new Error(`Unsupported artifact format: ${format}.`);
+  if (!REDACTION_PROFILES.has(redactionProfile)) {
+    throw new Error(`Unsupported artifact redaction profile: ${redactionProfile}.`);
+  }
+  const artifactPath = readString(value.path, `manifest.artifacts[${index}].path`);
+  const pathCheck = validateReporterArtifactPath({
+    outputDir: process.cwd(),
+    relativePath: artifactPath
+  });
+  if (!pathCheck.ok || pathCheck.relativePath === void 0) {
+    throw new Error(`Unsafe reporter artifact path: ${artifactPath}.`);
+  }
+  return {
+    kind,
+    path: pathCheck.relativePath,
+    format,
+    redactionProfile
+  };
+}
+function readArtifacts(value, label) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) throw new Error(`${label} must be an array.`);
+  return value.map((item, index) => readArtifact(item, index));
+}
+function readDiagnosticsCount(value, label) {
+  if (value === void 0) return 0;
+  if (!Array.isArray(value)) throw new Error(`${label} must be an array.`);
+  return value.length;
+}
+function readResult(value, index) {
+  if (!isObject(value)) throw new Error(`manifest.results[${index}] must be an object.`);
+  const file = readOptionalString(value.file);
+  const tracePath = readOptionalString(value.tracePath);
+  return {
+    testId: readString(value.testId, `manifest.results[${index}].testId`),
+    name: readString(value.name, `manifest.results[${index}].name`),
+    ...file === void 0 ? {} : { file },
+    status: readStatus(value.status),
+    ...tracePath === void 0 ? {} : { tracePath },
+    artifacts: readArtifacts(value.artifacts, `manifest.results[${index}].artifacts`),
+    diagnostics: readDiagnosticsCount(
+      value.diagnostics,
+      `manifest.results[${index}].diagnostics`
+    )
+  };
+}
+function readManifestDocument(value) {
+  if (!isObject(value)) throw new Error("Reporter manifest file must contain a JSON object.");
+  const candidate = isObject(value.manifest) ? value.manifest : value;
+  if (!isObject(candidate)) throw new Error("Reporter manifest must be a JSON object.");
+  const schemaVersion = readString(candidate.schemaVersion, "manifest.schemaVersion");
+  if (schemaVersion !== "0.1") {
+    throw new Error(`Unsupported reporter manifest schemaVersion: ${schemaVersion}.`);
+  }
+  if (!Array.isArray(candidate.results)) {
+    throw new Error("manifest.results must be an array.");
+  }
+  const artifacts = readArtifacts(candidate.artifacts, "manifest.artifacts");
+  const results = candidate.results.map((item, index) => readResult(item, index));
+  const diagnostics = readDiagnosticsCount(candidate.diagnostics, "manifest.diagnostics");
+  const manifest = {
+    framework: readFramework(candidate.framework),
+    generatedAt: readString(candidate.generatedAt, "manifest.generatedAt"),
+    results,
+    artifacts
+  };
+  return {
+    packageName: readOptionalString(value.package),
+    manifest,
+    diagnostics
+  };
+}
+function cwdRelative(filePath) {
+  const relative = path13.relative(process.cwd(), path13.resolve(filePath)).replace(/\\/g, "/");
+  if (relative === "" || relative.startsWith("../") || path13.isAbsolute(relative)) {
+    return path13.basename(filePath);
+  }
+  return relative;
+}
+async function readReporterManifest(filePath) {
+  const absolute = path13.resolve(filePath);
+  const raw = await readFile(absolute, "utf-8");
+  const document = readManifestDocument(JSON.parse(raw));
+  const manifest = document.manifest;
+  const results = manifest.results.map((result) => ({
+    testId: safeText(result.testId),
+    name: safeText(result.name),
+    ...result.file === void 0 ? {} : { file: safeText(path13.basename(result.file)) },
+    status: result.status,
+    ...result.tracePath === void 0 ? {} : { tracePath: safeText(path13.basename(result.tracePath)) },
+    artifacts: result.artifacts,
+    diagnostics: result.diagnostics
+  }));
+  return {
+    ...document.packageName === void 0 ? {} : { packageName: document.packageName },
+    manifestFile: cwdRelative(absolute),
+    framework: manifest.framework,
+    generatedAt: manifest.generatedAt,
+    results,
+    artifacts: manifest.artifacts,
+    diagnostics: document.diagnostics
+  };
+}
+function summarize3(manifests) {
+  const summary = {
+    manifests: manifests.length,
+    tests: 0,
+    failed: 0,
+    passed: 0,
+    skipped: 0,
+    todo: 0,
+    artifacts: 0,
+    diagnostics: 0
+  };
+  for (const manifest of manifests) {
+    summary.artifacts += manifest.artifacts.length;
+    summary.diagnostics += manifest.diagnostics;
+    for (const result of manifest.results) {
+      summary.tests += 1;
+      if (result.status === "failed") summary.failed += 1;
+      else if (result.status === "passed") summary.passed += 1;
+      else if (result.status === "skipped") summary.skipped += 1;
+      else summary.todo += 1;
+      summary.artifacts += result.artifacts.length;
+      summary.diagnostics += result.diagnostics;
+    }
+  }
+  return {
+    status: summary.failed > 0 ? "failed" : summary.diagnostics > 0 ? "warning" : "ok",
+    manifests,
+    summary,
+    note: NOTE2
+  };
+}
+function markdownCell(value) {
+  return safeText(String(value ?? "unknown")).replaceAll("|", "\\|").replace(/\r?\n/g, " ");
+}
+function renderMarkdown2(result) {
+  const lines = [
+    "# AgentInspect CI Summary",
+    "",
+    NOTE2,
+    "",
+    "| Field | Value |",
+    "| --- | --- |",
+    `| Status | ${result.status} |`,
+    `| Manifests | ${result.summary.manifests} |`,
+    `| Tests | ${result.summary.tests} |`,
+    `| Failed | ${result.summary.failed} |`,
+    `| Passed | ${result.summary.passed} |`,
+    `| Skipped | ${result.summary.skipped} |`,
+    `| Todo | ${result.summary.todo} |`,
+    `| Artifacts | ${result.summary.artifacts} |`,
+    `| Diagnostics | ${result.summary.diagnostics} |`,
+    "",
+    "## Tests",
+    "",
+    "| Framework | Status | Test | File | Trace | Artifacts |",
+    "| --- | --- | --- | --- | --- | --- |"
+  ];
+  const rows = result.manifests.flatMap(
+    (manifest) => manifest.results.map((test) => ({
+      framework: manifest.framework,
+      test
+    }))
+  );
+  if (rows.length === 0) {
+    lines.push("| unknown | unknown | No tests found | unknown | unknown | 0 |");
+  } else {
+    for (const row of rows) {
+      lines.push(
+        `| ${markdownCell(row.framework)} | ${markdownCell(row.test.status)} | ${markdownCell(row.test.name)} | ${markdownCell(row.test.file)} | ${markdownCell(row.test.tracePath)} | ${row.test.artifacts.length} |`
+      );
+    }
+  }
+  lines.push("", "## Manifests", "", "| Framework | File | Generated | Artifacts |", "| --- | --- | --- | --- |");
+  for (const manifest of result.manifests) {
+    lines.push(
+      `| ${markdownCell(manifest.framework)} | ${markdownCell(manifest.manifestFile)} | ${markdownCell(manifest.generatedAt)} | ${manifest.artifacts.length} |`
+    );
+  }
+  lines.push("", "## Artifacts", "", "| Framework | Kind | Path | Format | Profile |", "| --- | --- | --- | --- | --- |");
+  const artifacts = result.manifests.flatMap(
+    (manifest) => manifest.artifacts.map((artifact) => ({ framework: manifest.framework, artifact }))
+  );
+  if (artifacts.length === 0) {
+    lines.push("| unknown | unknown | No artifacts found | unknown | unknown |");
+  } else {
+    for (const row of artifacts) {
+      lines.push(
+        `| ${markdownCell(row.framework)} | ${markdownCell(row.artifact.kind)} | ${markdownCell(row.artifact.path)} | ${markdownCell(row.artifact.format)} | ${markdownCell(row.artifact.redactionProfile)} |`
+      );
+    }
+  }
+  lines.push("");
+  return `${lines.join("\n")}
+`;
+}
+function safeText(value) {
+  const compact = value.replace(/\s+/g, " ").trim();
+  const redacted = compact.replace(/\bsk-[A-Za-z0-9_-]{8,}\b/g, "[REDACTED]").replace(
+    /\b(?:api[_-]?key|authorization|token|secret|password)\s*[:=]\s*[^,\s]+/gi,
+    "$1=[REDACTED]"
+  );
+  if (redacted.length <= MAX_TEXT) return redacted;
+  return `${redacted.slice(0, MAX_TEXT - 12)}...[truncated]`;
+}
+async function ciSummaryCommand(manifestPaths, options = {}) {
+  if (manifestPaths.length === 0) {
+    console.error("At least one reporter manifest path is required.");
+    process.exitCode = 1;
+    return;
+  }
+  let result;
+  try {
+    const manifests = [];
+    for (const manifestPath of manifestPaths) {
+      manifests.push(await readReporterManifest(manifestPath));
+    }
+    manifests.sort((a, b) => a.manifestFile.localeCompare(b.manifestFile));
+    result = summarize3(manifests);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[AgentInspect] ci-summary failed: ${message}`);
+    process.exitCode = 1;
+    return;
+  }
+  const markdown = renderMarkdown2(result);
+  const outputPath = options.output !== void 0 && options.output.trim() !== "" ? path13.resolve(options.output.trim()) : void 0;
+  if (outputPath !== void 0) {
+    await mkdir(path13.dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, markdown, "utf-8");
+  }
+  const summaryTarget = options.githubSummary ?? process.env.GITHUB_STEP_SUMMARY;
+  if (summaryTarget !== void 0 && summaryTarget.trim() !== "") {
+    const summaryPath = path13.resolve(summaryTarget);
+    await mkdir(path13.dirname(summaryPath), { recursive: true });
+    await appendFile(summaryPath, `
+${markdown}`, "utf-8");
+  }
+  if (options.json === true) {
+    console.log(writeJson4(result).trimEnd());
+  } else if (outputPath !== void 0) {
+    console.log(`Wrote AgentInspect CI summary to ${outputPath}`);
+    console.log(`Status: ${result.status}`);
+  } else {
+    console.log(markdown.trimEnd());
+  }
+}
 
 // packages/cli/src/index.ts
 function runCommand(action) {
@@ -11108,6 +12965,36 @@ function createCliProgram() {
   ]).option("--max-total-tokens <number>", "add llm.usage with a max total-token budget").action((target, opts) => {
     runCommand(() => checkCommand(target, opts));
   });
+  program.command("eval").description("Run deterministic local evals against a trace").argument("<trace-path-or-run-id>", "trace file, directory, stdin -, or run id").option("--dir <path>", "trace directory for run-id lookup").addOption(
+    new Option("--format <format>", "trace input format").choices([
+      "agent-inspect-jsonl",
+      "openinference-json",
+      "otlp-json"
+    ])
+  ).option("--run <run-id>", "select a run when the trace contains multiple runs").option("--config <path>", "path to eval config (.json, .js, .mjs, .cjs)").option("--json", "print deterministic JSON eval result").option("--markdown", "print deterministic Markdown eval summary").option("--require-success", "require the selected run to complete successfully").option("--required-tool <name>", "require a tool name (repeatable)", (value, previous = []) => [
+    ...previous,
+    value
+  ]).option("--forbid-tool <name>", "forbid a tool name (repeatable)", (value, previous = []) => [
+    ...previous,
+    value
+  ]).option("--forbidden-tool <name>", "alias for --forbid-tool (repeatable)", (value, previous = []) => [
+    ...previous,
+    value
+  ]).option("--max-duration-ms <number>", "require run duration at or below this value").option("--max-depth <number>", "require tree depth at or below this value").option("--max-retries <number>", "require retry counts at or below this value").option("--max-total-tokens <number>", "require total LLM tokens at or below this value").option(
+    "--require-retrieval-before-generation",
+    "require a retrieval step before the first LLM generation"
+  ).option("--required-decision-metadata <key>", "require decision metadata (repeatable)", (value, previous = []) => [
+    ...previous,
+    value
+  ]).option("--context-overlap", "require answer/context token overlap").option("--min-context-overlap <number>", "minimum answer/context overlap ratio").option("--min-shared-terms <number>", "minimum shared answer/context terms").option("--quote-overlap", "require quoted answer text to appear in context").option("--citation-presence", "require a citation or source reference").option("--required-source-id <id>", "require a source id in context or citations (repeatable)", (value, previous = []) => [
+    ...previous,
+    value
+  ]).option("--min-answer-characters <number>", "minimum answer character count").option("--max-answer-characters <number>", "maximum answer character count").option("--min-answer-words <number>", "minimum answer word count").option("--max-answer-words <number>", "maximum answer word count").option("--banned-phrase <text>", "ban unsupported-answer phrasing (repeatable)", (value, previous = []) => [
+    ...previous,
+    value
+  ]).action((target, opts) => {
+    runCommand(() => evalCommand(target, opts));
+  });
   program.command("scan").description("Best-effort local safety scan for trace capture risks").argument("<trace-path-or-run-id>", "trace file, directory, stdin -, or run id").option("--dir <path>", "trace directory for run-id lookup").addOption(
     new Option("--format <format>", "trace input format").choices([
       "agent-inspect-jsonl",
@@ -11135,6 +13022,9 @@ function createCliProgram() {
   ).option("--run <run-id>", "select a run when the trace contains multiple runs").option("--baseline <trace-path-or-run-id>", "optional baseline trace for diff artifacts").option("--baseline-run <run-id>", "select a run from the baseline trace").option("--github-summary <path>", "append a safe summary to this file, e.g. GITHUB_STEP_SUMMARY").option("--json", "print deterministic JSON manifest").action((target, opts) => {
     runCommand(() => artifactsCommand(target, opts));
   });
+  program.command("ci-summary").description("Summarize local reporter artifact manifests for CI").argument("<manifest...>", "reporter artifact manifest JSON files").option("-o, --output <path>", "write Markdown summary to a local file").option("--github-summary <path>", "append Markdown summary to this local file, e.g. GITHUB_STEP_SUMMARY").option("--json", "print deterministic JSON summary").action((manifest, opts) => {
+    runCommand(() => ciSummaryCommand(manifest, opts));
+  });
   program.command("diff").description("Compare two local AgentInspect JSONL traces (read-only)").argument("<left-run-id>", "first run id").argument("<right-run-id>", "second run id").option("--dir <path>", "trace directory").option("--json", "print diff result as JSON").option("--ignore-duration", "omit duration comparisons").option(
     "--duration-threshold <duration>",
     "ignore duration deltas at or below this (e.g. 500ms, 2s, 1m)"
@@ -11195,6 +13085,14 @@ function createCliProgram() {
   ).action((runId, opts) => {
     runCommand(() => reportCommand(runId, opts));
   });
+  program.command("redact").description("Redact a local JSON or JSONL trace/file").argument("<trace-or-file>", "trace file, JSON file, stdin -, or run id").option("--dir <path>", "trace directory for run-id lookup").addOption(
+    new Option(
+      "--profile <profile>",
+      "redaction profile: local, share, strict (default: share)"
+    ).choices(["local", "share", "strict"])
+  ).option("-o, --output <path>", "write redacted content to a file").option("--json", "print deterministic JSON wrapper with findings").action((target, opts) => {
+    runCommand(() => redactCommand(target, opts));
+  });
   program.command("explain").description("Explain a local trace with deterministic facts (no provider calls)").argument("<trace-path-or-run-id>", "trace file, directory, stdin -, or run id").option("--dir <path>", "trace directory for run-id lookup").addOption(
     new Option("--format <format>", "trace input format").choices([
       "agent-inspect-jsonl",
@@ -11219,9 +13117,9 @@ function isPrimaryModule() {
   if (!entry) return false;
   const selfPath = fileURLToPath(import.meta.url);
   try {
-    return realpathSync(path10.resolve(entry)) === realpathSync(path10.resolve(selfPath));
+    return realpathSync(path13.resolve(entry)) === realpathSync(path13.resolve(selfPath));
   } catch {
-    return path10.resolve(entry) === path10.resolve(selfPath);
+    return path13.resolve(entry) === path13.resolve(selfPath);
   }
 }
 if (isPrimaryModule()) {