agent-inspect 2.4.0 → 2.6.0

package/packages/cli/dist/index.mjs

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
 import { realpathSync, createReadStream } from 'fs';
-import path13 from 'path';
+import path14 from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { Command, Option } from 'commander';
 import { AsyncLocalStorage } from 'async_hooks';
-import crypto, { webcrypto } from 'crypto';
+import crypto, { webcrypto, createHash } from 'crypto';
 import { unlink, stat, mkdir, writeFile, appendFile, readdir, readFile, access, open } from 'fs/promises';
 import os from 'os';
 import process2, { stdin, stdout } from 'process';
 import tty from 'tty';
 import { createInterface } from 'readline';
+import { createServer } from 'http';
 
 // package.json
-var version = "2.4.0";
+var version = "2.6.0";
 
 // packages/core/src/correlation-metadata.ts
 var TRACE_CORRELATION_KEYS = [
@@ -744,7 +745,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 = path13.join(
+var FALLBACK_TRACE_DIR = path14.join(
   os.tmpdir(),
   "agent-inspect",
   RUNS_DIR_NAME
@@ -779,7 +780,7 @@ function getDefaultTraceDir() {
     if (typeof home !== "string" || home.trim() === "") {
       return FALLBACK_TRACE_DIR;
     }
-    return path13.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
+    return path14.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
   } catch {
     return FALLBACK_TRACE_DIR;
   }
@@ -787,11 +788,11 @@ function getDefaultTraceDir() {
 function getTraceFilePath(runId, traceDir) {
   const baseDir = traceDir ?? getDefaultTraceDir();
   let safeId = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "run_unknown";
-  safeId = path13.basename(safeId);
+  safeId = path14.basename(safeId);
   if (safeId === "" || safeId === "." || safeId === "..") {
     safeId = "run_unknown";
   }
-  return path13.join(baseDir, `${safeId}.jsonl`);
+  return path14.join(baseDir, `${safeId}.jsonl`);
 }
 function formatError(error) {
   if (error instanceof Error) {
@@ -1429,18 +1430,18 @@ var proto = Object.defineProperties(() => {
     }
   }
 });
-var createStyler = (open2, close, parent) => {
+var createStyler = (open3, close, parent) => {
   let openAll;
   let closeAll;
   if (parent === void 0) {
-    openAll = open2;
+    openAll = open3;
     closeAll = close;
   } else {
-    openAll = parent.openAll + open2;
+    openAll = parent.openAll + open3;
     closeAll = close + parent.closeAll;
   }
   return {
-    open: open2,
+    open: open3,
     close,
     openAll,
     closeAll,
@@ -1505,15 +1506,15 @@ function getStatusIcon(status) {
   if (status === "error") return source_default.red("\u2716");
   return source_default.yellow("\u23F3");
 }
-function renderStepLine(name, durationMs, status, depth) {
+function renderStepLine(name, durationMs2, status, depth) {
   try {
     const nm = formatTerminalName(name);
     const ind = getIndent(depth ?? 0);
-    if (status === "running" && durationMs === void 0) {
+    if (status === "running" && durationMs2 === void 0) {
       return `${ind}${source_default.yellow("\u23F3")} ${nm}`;
     }
-    const hasDur = durationMs !== void 0 && Number.isFinite(durationMs);
-    const dur = hasDur ? formatDuration2(durationMs) : void 0;
+    const hasDur = durationMs2 !== void 0 && Number.isFinite(durationMs2);
+    const dur = hasDur ? formatDuration2(durationMs2) : void 0;
     if (status === "running") {
       return dur !== void 0 ? `${ind}${source_default.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${source_default.yellow("\u23F3")} ${nm}`;
     }
@@ -1553,7 +1554,7 @@ var TraceDirectory = class {
     this.#dir = resolveTraceDir(options);
   }
   getPath(filename) {
-    return filename ? path13.join(this.#dir, filename) : this.#dir;
+    return filename ? path14.join(this.#dir, filename) : this.#dir;
   }
   async list() {
     try {
@@ -1580,7 +1581,7 @@ function parseIsoToMs2(value) {
 }
 async function extractMetadata(filePath, _quickScan) {
   const stats = await stat(filePath);
-  let runIdFromFile = path13.basename(filePath);
+  let runIdFromFile = path14.basename(filePath);
   if (runIdFromFile.endsWith(".jsonl")) {
     runIdFromFile = runIdFromFile.slice(0, -".jsonl".length);
   }
@@ -1666,14 +1667,14 @@ async function extractMetadata(filePath, _quickScan) {
   } else {
     status = "unknown";
   }
-  const durationMs = explicitDurationMs ?? (startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt ? endedAt - startedAt : void 0);
+  const durationMs2 = explicitDurationMs ?? (startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt ? endedAt - startedAt : void 0);
   return {
     runId: resolvedRunId,
     name,
     status,
     startedAt,
     endedAt,
-    durationMs,
+    durationMs: durationMs2,
     eventCount: parsedTrace.sourceEventCount,
     filePath,
     fileSize: stats.size,
@@ -1694,7 +1695,7 @@ function buildRunSummary(events) {
   const runId = started?.runId ?? events.find((e) => typeof e.runId === "string")?.runId ?? "unknown-run";
   const name = typeof started?.name === "string" && started.name.trim() !== "" ? started.name : void 0;
   const status = lastCompleted ? lastCompleted.status : started ? "running" : "unknown";
-  const durationMs = lastCompleted && isFiniteNumber(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const durationMs2 = lastCompleted && isFiniteNumber(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
   started && isFiniteNumber(started.startTime) ? started.startTime : void 0;
   const steps = /* @__PURE__ */ new Map();
   for (const e of events) {
@@ -1784,7 +1785,7 @@ function buildRunSummary(events) {
     runId,
     name,
     status,
-    durationMs,
+    durationMs: durationMs2,
     totalSteps,
     llmSteps,
     toolSteps,
@@ -3058,12 +3059,12 @@ function buildCriticalPath(runs, handoffs) {
     handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.from)
   );
   const ordered = [...runs].sort(compareRuns);
-  const path15 = [];
+  const path16 = [];
   const visited = /* @__PURE__ */ new Set();
   const pushRun = (run, confidence, source) => {
     if (visited.has(run.runId)) return;
     visited.add(run.runId);
-    path15.push({
+    path16.push({
       runId: run.runId,
       name: run.name,
       startedAt: run.startedAt,
@@ -3088,7 +3089,7 @@ function buildCriticalPath(runs, handoffs) {
     const confidence = explicitTargets.has(run.runId) || explicitSources.has(run.runId) ? "explicit" : "correlated";
     pushRun(run, confidence, confidence === "explicit" ? "manual" : "inferred");
   }
-  return path15;
+  return path16;
 }
 function metaRunIdMatches(run, token, runById) {
   const meta = extractSessionWorkflowMetadata(run.metadata);
@@ -3215,10 +3216,10 @@ function statusIcon(status) {
   if (status === "running") return "\u23F3";
   return "?";
 }
-function durationCell(status, durationMs) {
+function durationCell(status, durationMs2) {
   if (status === "running" || status === "unknown") return "-";
-  if (durationMs !== void 0 && Number.isFinite(durationMs)) {
-    return formatDuration2(durationMs);
+  if (durationMs2 !== void 0 && Number.isFinite(durationMs2)) {
+    return formatDuration2(durationMs2);
   }
   return "-";
 }
@@ -3875,7 +3876,7 @@ var TreeBuilder = class {
       const startedAt = sorted.length > 0 ? sorted[0].timestamp : void 0;
       const endedAt = sorted.length > 0 ? sorted[sorted.length - 1].timestamp : void 0;
       const status = computeRunStatus(sorted);
-      const durationMs = startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt && status !== "running" ? endedAt - startedAt : void 0;
+      const durationMs2 = startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt && status !== "running" ? endedAt - startedAt : void 0;
       const name = sorted.find((e) => e.kind === "RUN")?.name;
       out.push({
         runId,
@@ -3883,7 +3884,7 @@ var TreeBuilder = class {
         status,
         startedAt,
         endedAt: status === "running" ? void 0 : endedAt,
-        durationMs,
+        durationMs: durationMs2,
         children: roots,
         metadata: {
           totalEvents: sorted.length,
@@ -4026,7 +4027,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) => path13.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path14.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
 }
 async function resolveInput(input3) {
   const cached = resolvedInputCache.get(input3);
@@ -4578,9 +4579,9 @@ function mapOpenInferenceSpan(span, index, version2) {
   if (endedAt !== void 0) {
     event.endedAt = endedAt;
   }
-  const durationMs = durationBetweenIso(startedAt, endedAt);
-  if (durationMs !== void 0) {
-    event.durationMs = durationMs;
+  const durationMs2 = durationBetweenIso(startedAt, endedAt);
+  if (durationMs2 !== void 0) {
+    event.durationMs = durationMs2;
   }
   if (tokenUsage !== void 0) {
     event.tokenUsage = tokenUsage;
@@ -5165,9 +5166,9 @@ function mapOtlpSpan(context) {
   if (endedAt !== void 0) {
     event.endedAt = endedAt;
   }
-  const durationMs = durationBetweenIso(startedAt, endedAt);
-  if (durationMs !== void 0) {
-    event.durationMs = durationMs;
+  const durationMs2 = durationBetweenIso(startedAt, endedAt);
+  if (durationMs2 !== void 0) {
+    event.durationMs = durationMs2;
   }
   if (tokenUsage !== void 0) {
     event.tokenUsage = tokenUsage;
@@ -6172,13 +6173,13 @@ var EventNormalizer = class {
     const timestampMissing = parsedTs === void 0;
     const parentIdKey = cfg.parentIdKey;
     const parentId = parentIdKey ? safeString(raw[parentIdKey]) : void 0;
-    let durationMs;
+    let durationMs2;
     const durationKey = cfg.durationKey;
     if (durationKey) {
       const v = raw[durationKey];
-      if (isFiniteNumber2(v)) durationMs = v;
+      if (isFiniteNumber2(v)) durationMs2 = v;
     } else if (isFiniteNumber2(raw.durationMs)) {
-      durationMs = raw.durationMs;
+      durationMs2 = raw.durationMs;
     }
     let status;
     const statusKey = cfg.statusKey;
@@ -6225,7 +6226,7 @@ var EventNormalizer = class {
       kind,
       timestamp,
       ...status ? { status } : {},
-      ...durationMs !== void 0 ? { durationMs } : {},
+      ...durationMs2 !== void 0 ? { durationMs: durationMs2 } : {},
       ...Object.keys(attributes).length > 0 ? { attributes } : {},
       confidence,
       source: {
@@ -7813,7 +7814,7 @@ function manualTraceEventsToRunTree(events) {
   }
   const startedAt = started.startTime;
   const endedAt = lastCompleted !== void 0 && runStatus !== "running" ? lastCompleted.endTime : void 0;
-  const durationMs = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const durationMs2 = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
   const steps = /* @__PURE__ */ new Map();
   for (const e of events) {
     if (e.event !== "step_started") continue;
@@ -7902,7 +7903,7 @@ function manualTraceEventsToRunTree(events) {
     status: runStatus,
     startedAt,
     endedAt,
-    durationMs,
+    durationMs: durationMs2,
     children: roots,
     metadata: {
       totalEvents: inspectNodes.size,
@@ -8152,9 +8153,9 @@ Trace directory: ${traceDir}`);
   if (validation !== void 0 && !validation.ok) {
     process.exitCode = 1;
   }
-  const outPath = options.output !== void 0 && options.output.trim() !== "" ? path13.resolve(options.output.trim()) : void 0;
+  const outPath = options.output !== void 0 && options.output.trim() !== "" ? path14.resolve(options.output.trim()) : void 0;
   if (outPath !== void 0) {
-    await mkdir(path13.dirname(outPath), { recursive: true });
+    await mkdir(path14.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})`);
@@ -8215,7 +8216,7 @@ function manualTraceEventsToComparableRun(events) {
   let runStatus;
   if (lastCompleted === void 0) runStatus = "running";
   else runStatus = lastCompleted.status;
-  const durationMs = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const durationMs2 = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
   const steps = /* @__PURE__ */ new Map();
   let order = 0;
   for (const e of events) {
@@ -8286,7 +8287,7 @@ function manualTraceEventsToComparableRun(events) {
     runId,
     name: rs.name,
     status: runStatus,
-    durationMs,
+    durationMs: durationMs2,
     steps: roots
   };
 }
@@ -8331,13 +8332,13 @@ function pairSteps(left, right) {
   return pairs;
 }
 function compareLeafSteps(L, R, segments, opts, out) {
-  const path15 = buildPath(segments);
+  const path16 = buildPath(segments);
   if (L.name !== R.name) {
     out.push({
       kind: "structure",
       severity: "warning",
       message: "Step name differs",
-      path: path15,
+      path: path16,
       left: L.name,
       right: R.name
     });
@@ -8347,7 +8348,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-type",
       severity: "warning",
       message: "Step type differs",
-      path: path15,
+      path: path16,
       left: L.type,
       right: R.type
     });
@@ -8357,7 +8358,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-status",
       severity: "warning",
       message: "Step status differs",
-      path: path15,
+      path: path16,
       left: L.status,
       right: R.status
     });
@@ -8369,7 +8370,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "error",
       severity: "error",
       message: "Step error message differs",
-      path: path15,
+      path: path16,
       left: le || void 0,
       right: re || void 0
     });
@@ -8387,7 +8388,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
         kind: "duration",
         severity: "info",
         message: "Step duration differs",
-        path: path15,
+        path: path16,
         left: ld,
         right: rd
       });
@@ -8400,7 +8401,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "metadata",
       severity: "info",
       message: "Step metadata differs",
-      path: path15,
+      path: path16,
       left: L.metadata,
       right: R.metadata
     });
@@ -8412,7 +8413,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "output",
       severity: "info",
       message: "Output preview differs",
-      path: path15,
+      path: path16,
       left: L.outputPreview,
       right: R.outputPreview
     });
@@ -8572,11 +8573,11 @@ function diffRuns(left, right, options) {
 }
 
 // packages/core/src/diff/renderer.ts
-function formatPath(path15) {
-  if (path15 === void 0 || path15.path.length === 0) {
+function formatPath(path16) {
+  if (path16 === void 0 || path16.path.length === 0) {
     return "(run)";
   }
-  return path15.path.map((s) => s.name).join(" > ");
+  return path16.path.map((s) => s.name).join(" > ");
 }
 function formatValue(v, verbose) {
   if (v === void 0) return "(undefined)";
@@ -9205,9 +9206,9 @@ async function reportCommand(runId, options = {}) {
     redactionProfile,
     correlation: !options.noCorrelation
   });
-  const outPath = options.output !== void 0 && options.output.trim() !== "" ? path13.resolve(options.output.trim()) : void 0;
+  const outPath = options.output !== void 0 && options.output.trim() !== "" ? path14.resolve(options.output.trim()) : void 0;
   if (outPath !== void 0) {
-    await mkdir(path13.dirname(outPath), { recursive: true });
+    await mkdir(path14.dirname(outPath), { recursive: true });
     await writeFile(outPath, result.content, "utf-8");
     console.log(`Wrote ${result.fileExtension} report to ${outPath}`);
   }
@@ -9454,17 +9455,17 @@ function applyRule(rule, value, replacement) {
   }
   return value;
 }
-function childPath(path15, key) {
+function childPath(path16, key) {
   if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) {
-    return path15 ? `${path15}.${key}` : key;
+    return path16 ? `${path16}.${key}` : key;
   }
-  return `${path15 || "$"}[${JSON.stringify(key)}]`;
+  return `${path16 || "$"}[${JSON.stringify(key)}]`;
 }
-function indexPath(path15, index) {
-  return `${path15 || "$"}[${index}]`;
+function indexPath(path16, index) {
+  return `${path16 || "$"}[${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 makeFinding(path16, detector, action, matchKind, severity = "warning", preview) {
+  return preview === void 0 ? { path: path16, detector, action, severity, matchKind } : { path: path16, detector, action, severity, matchKind, preview };
 }
 function createRedactionProfile(profile = "local") {
   switch (profile) {
@@ -9533,11 +9534,11 @@ var Redactor2 = class {
   #recordFinding(state, finding) {
     if (this.#collectFindings) state.findings.push(finding);
   }
-  #redactValue(value, key, path15, depth, state) {
+  #redactValue(value, key, path16, depth, state) {
     if (depth > this.#maxDepth) {
       this.#recordFinding(
         state,
-        makeFinding(path15, "structure.maxDepth", "truncate", "value", "warning")
+        makeFinding(path16, "structure.maxDepth", "truncate", "value", "warning")
       );
       return "[Truncated]";
     }
@@ -9546,19 +9547,19 @@ var Redactor2 = class {
       if (rule) {
         this.#recordFinding(
           state,
-          makeFinding(path15, `key.${rule.key}`, actionForRule(rule), "key", "warning")
+          makeFinding(path16, `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 });
+      const detections = detector.detect({ path: path16, key, value });
       for (const detection of detections) {
         const action = detection.action ?? "replace";
         this.#recordFinding(
           state,
           makeFinding(
-            path15,
+            path16,
             detector.id,
             action,
             detection.matchKind ?? detector.matchKind ?? "custom",
@@ -9576,7 +9577,7 @@ var Redactor2 = class {
       const out = [];
       state.seen.set(value, out);
       value.forEach((item, index) => {
-        out[index] = this.#redactValue(item, void 0, indexPath(path15, index), depth + 1, state);
+        out[index] = this.#redactValue(item, void 0, indexPath(path16, index), depth + 1, state);
       });
       return out;
     }
@@ -9588,7 +9589,7 @@ var Redactor2 = class {
         out[entryKey] = this.#redactValue(
           entryValue,
           entryKey,
-          childPath(path15 === "$" ? "" : path15, entryKey),
+          childPath(path16 === "$" ? "" : path16, entryKey),
           depth + 1,
           state
         );
@@ -10035,14 +10036,14 @@ function uniqueSorted(values) {
   return [...new Set(values)].sort();
 }
 function isWithinDirectory(child, parent) {
-  const relative = path13.relative(parent, child);
-  return relative === "" || !relative.startsWith("..") && !path13.isAbsolute(relative);
+  const relative = path14.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path14.isAbsolute(relative);
 }
 async function resolveOutputPath(inputPath, output2, force) {
   if (output2 === void 0 || output2.trim() === "") return void 0;
-  const inputAbs = path13.resolve(inputPath);
-  const outputAbs = path13.resolve(output2.trim());
-  const inputDir = path13.dirname(inputAbs);
+  const inputAbs = path14.resolve(inputPath);
+  const outputAbs = path14.resolve(output2.trim());
+  const inputDir = path14.dirname(inputAbs);
   if (!isWithinDirectory(outputAbs, inputDir)) {
     throw new Error("Refusing to write migrated output outside the input directory.");
   }
@@ -10163,7 +10164,7 @@ async function migrateCommand(input3, options = {}) {
     process.exitCode = 1;
     return;
   }
-  const inputPath = path13.resolve(input3.trim());
+  const inputPath = path14.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>.");
@@ -10182,7 +10183,7 @@ async function migrateCommand(input3, options = {}) {
     );
     const result = await buildMigration(inputPath, outputPath);
     if (!dryRun && outputPath !== void 0) {
-      await mkdir(path13.dirname(outputPath), { recursive: true });
+      await mkdir(path14.dirname(outputPath), { recursive: true });
       await writeFile(outputPath, result.content, "utf-8");
     }
     printSummary2(result, dryRun);
@@ -10460,7 +10461,7 @@ function stripPrefix(name, prefixes) {
   }
   return name;
 }
-function eventEvidence(event, path15) {
+function eventEvidence(event, path16) {
   return {
     runId: event.runId,
     eventId: event.eventId,
@@ -10470,7 +10471,7 @@ function eventEvidence(event, path15) {
     kind: event.kind,
     name: event.name,
     status: event.status,
-    ...path15 ? { path: path15 } : {}
+    ...path16 ? { path: path16 } : {}
   };
 }
 function runEvidence(run) {
@@ -10533,9 +10534,9 @@ function eventEndMs(event) {
 function normalizedKey(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]/g, "");
 }
-function lastPathSegment(path15) {
-  const parts = path15.split(".");
-  return parts[parts.length - 1] ?? path15;
+function lastPathSegment(path16) {
+  const parts = path16.split(".");
+  return parts[parts.length - 1] ?? path16;
 }
 function valueType(value) {
   if (Array.isArray(value)) return "array";
@@ -10549,12 +10550,12 @@ function serializedByteLength(value) {
     return void 0;
   }
 }
-function pushValueEntries(entries, event, value, path15, key, depth = 0) {
-  entries.push({ event, path: path15, key, value });
+function pushValueEntries(entries, event, value, path16, key, depth = 0) {
+  entries.push({ event, path: path16, key, value });
   if (depth >= 8) return;
   if (Array.isArray(value)) {
     for (const [index, item] of value.entries()) {
-      pushValueEntries(entries, event, item, `${path15}.${index}`, String(index), depth + 1);
+      pushValueEntries(entries, event, item, `${path16}.${index}`, String(index), depth + 1);
     }
     return;
   }
@@ -10564,7 +10565,7 @@ function pushValueEntries(entries, event, value, path15, key, depth = 0) {
       entries,
       event,
       value[nestedKey],
-      `${path15}.${nestedKey}`,
+      `${path16}.${nestedKey}`,
       nestedKey,
       depth + 1
     );
@@ -10645,9 +10646,9 @@ function eventDurationMs(event) {
 }
 function treeShape(nodes) {
   const lines = [];
-  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}`));
+  const visit = (node, path16) => {
+    lines.push(`${path16}:${node.event.kind}:${node.event.name}:${node.event.status ?? "unknown"}`);
+    node.children.forEach((child, index) => visit(child, `${path16}.${index}`));
   };
   nodes.forEach((node, index) => visit(node, String(index)));
   return lines;
@@ -10696,9 +10697,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, path15) {
+function firstEvidenceForKind(context, kind, path16) {
   const event = context.events.find((candidate) => candidate.kind === kind);
-  return event ? [eventEvidence(event, path15)] : runEvidence(context.selectedRun);
+  return event ? [eventEvidence(event, path16)] : runEvidence(context.selectedRun);
 }
 function baselineDiffFinding(message, evidence, expected, actual) {
   return failFinding("baseline.regression", message, evidence, expected, actual);
@@ -10946,13 +10947,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 path15 = [];
+        const path16 = [];
         const seenAt = /* @__PURE__ */ new Map();
         let current = event;
         while (current) {
           const existing = seenAt.get(current.eventId);
           if (existing !== void 0) {
-            const cycle = path15.slice(existing);
+            const cycle = path16.slice(existing);
             const key = cycle.map((item) => item.eventId).sort().join("\0");
             if (!seenCycles.has(key)) {
               seenCycles.add(key);
@@ -10968,8 +10969,8 @@ function createStructureCycleRule() {
             }
             break;
           }
-          seenAt.set(current.eventId, path15.length);
-          path15.push(current);
+          seenAt.set(current.eventId, path16.length);
+          path16.push(current);
           current = current.parentId ? byId.get(current.parentId) : void 0;
         }
       }
@@ -11180,7 +11181,7 @@ function createSafetyRawContentRule(options = {}) {
 }
 function createSafetySecretPatternRule(options = {}) {
   const patterns = options.patterns ?? DEFAULT_SECRET_PATTERNS;
-  const maxStringLength = options.maxStringLength ?? 4096;
+  const maxStringLength2 = options.maxStringLength ?? 4096;
   return {
     id: "safety.secretPattern",
     category: "safety",
@@ -11190,7 +11191,7 @@ function createSafetySecretPatternRule(options = {}) {
       for (const event of context.events) {
         for (const entry of eventValueEntries(event, { includeSummaries: true, includeError: true })) {
           if (typeof entry.value !== "string") continue;
-          const sample = entry.value.slice(0, maxStringLength);
+          const sample = entry.value.slice(0, maxStringLength2);
           for (const pattern of patterns) {
             pattern.pattern.lastIndex = 0;
             if (!pattern.pattern.test(sample)) continue;
@@ -11446,6 +11447,621 @@ function runTraceChecks(input3, options = {}) {
     diagnostics
   };
 }
+var ALL_RULES = [
+  "circuit.same-tool-repetition",
+  "circuit.same-args-repetition",
+  "circuit.max-loop-iterations",
+  "circuit.max-retries",
+  "circuit.tool-timeout",
+  "circuit.runaway-llm-loop",
+  "circuit.excessive-branch-width"
+];
+function closed(ruleId, message) {
+  return { ruleId, status: "closed", severity: "info", message, evidence: [] };
+}
+function open2(ruleId, message, evidence, severity = "error") {
+  return {
+    ruleId,
+    status: severity === "warning" ? "warn" : "open",
+    severity,
+    message,
+    evidence
+  };
+}
+function isToolEvent(event) {
+  const name = event.name.toLowerCase();
+  return event.kind === "tool" || name.startsWith("tool:") || name.startsWith("function:") || name.includes(".tool.") || name.startsWith("mcp:");
+}
+function isLlmEvent(event) {
+  const name = event.name.toLowerCase();
+  return event.kind === "llm" || name.startsWith("llm:") || name.includes(".llm.") || name.includes("generation");
+}
+function toolLabel(event) {
+  const attrs = event.attributes ?? {};
+  const fromAttr = attrs.toolName ?? attrs.tool ?? attrs.function;
+  if (typeof fromAttr === "string" && fromAttr.length > 0) return fromAttr;
+  return event.name.replace(/^(tool:|function:|mcp:)/i, "");
+}
+function argsHash(toolName2, args) {
+  return createHash("sha256").update(`${toolName2}:${JSON.stringify(args ?? null)}`).digest("hex").slice(0, 16);
+}
+function toolArgs(event) {
+  const attrs = event.attributes ?? {};
+  return attrs.arguments ?? attrs.args ?? attrs.input ?? attrs.parameters;
+}
+function durationMs(event) {
+  if (typeof event.durationMs === "number") return event.durationMs;
+  const attrs = event.attributes ?? {};
+  const fromAttr = attrs.durationMs ?? attrs.duration;
+  return typeof fromAttr === "number" ? fromAttr : void 0;
+}
+function attemptNumber(event) {
+  const attrs = event.attributes ?? {};
+  const value = attrs.attempt ?? attrs.retryAttempt ?? attrs.retryCount;
+  return typeof value === "number" ? value : void 0;
+}
+function evaluateSameToolRepetition(events, maxRepeats) {
+  const ruleId = "circuit.same-tool-repetition";
+  const counts = /* @__PURE__ */ new Map();
+  for (const event of events.filter(isToolEvent)) {
+    const label = toolLabel(event);
+    counts.set(label, (counts.get(label) ?? 0) + 1);
+  }
+  const evidence = [];
+  for (const [toolName2, count] of counts) {
+    if (count > maxRepeats) {
+      evidence.push({ ruleId, toolName: toolName2, count, threshold: maxRepeats });
+    }
+  }
+  if (evidence.length === 0) {
+    return closed(ruleId, "Tool repetition within threshold.");
+  }
+  return open2(ruleId, "Same tool repeated beyond threshold.", evidence);
+}
+function evaluateSameArgsRepetition(events, maxRepeats) {
+  const ruleId = "circuit.same-args-repetition";
+  const counts = /* @__PURE__ */ new Map();
+  for (const event of events.filter(isToolEvent)) {
+    const label = toolLabel(event);
+    const hash = argsHash(label, toolArgs(event));
+    const key = `${label}:${hash}`;
+    const current = counts.get(key) ?? { toolName: label, count: 0 };
+    current.count += 1;
+    counts.set(key, current);
+  }
+  const evidence = [];
+  for (const entry of counts.values()) {
+    if (entry.count > maxRepeats) {
+      evidence.push({ ruleId, toolName: entry.toolName, count: entry.count, threshold: maxRepeats });
+    }
+  }
+  if (evidence.length === 0) {
+    return closed(ruleId, "Tool argument repetition within threshold.");
+  }
+  return open2(ruleId, "Same tool arguments repeated beyond threshold.", evidence);
+}
+function evaluateMaxLoopIterations(events, maxIterations) {
+  const ruleId = "circuit.max-loop-iterations";
+  const iterationEvents = events.filter((event) => {
+    const attrs = event.attributes ?? {};
+    return typeof attrs.iteration === "number" || event.name.toLowerCase().includes("loop");
+  });
+  const maxSeen = iterationEvents.reduce((max, event) => {
+    const attrs = event.attributes ?? {};
+    const iteration = typeof attrs.iteration === "number" ? attrs.iteration : max;
+    return Math.max(max, iteration);
+  }, iterationEvents.length);
+  if (maxSeen <= maxIterations) {
+    return closed(ruleId, "Loop iterations within threshold.");
+  }
+  return open2(ruleId, "Loop iterations exceeded threshold.", [
+    { ruleId, count: maxSeen, threshold: maxIterations }
+  ]);
+}
+function evaluateMaxRetries(events, maxRetries) {
+  const ruleId = "circuit.max-retries";
+  const attempts = events.map(attemptNumber).filter((value) => value !== void 0);
+  const maxAttempt = attempts.length > 0 ? Math.max(...attempts) : 0;
+  if (maxAttempt <= maxRetries) {
+    return closed(ruleId, "Retry count within threshold.");
+  }
+  return open2(ruleId, "Retry count exceeded threshold.", [
+    { ruleId, count: maxAttempt, threshold: maxRetries }
+  ]);
+}
+function evaluateToolTimeout(events, maxDurationMs) {
+  const ruleId = "circuit.tool-timeout";
+  const evidence = [];
+  for (const event of events.filter(isToolEvent)) {
+    const duration = durationMs(event);
+    if (duration !== void 0 && duration > maxDurationMs) {
+      evidence.push({
+        ruleId,
+        toolName: toolLabel(event),
+        count: duration,
+        threshold: maxDurationMs,
+        eventId: event.eventId
+      });
+    }
+  }
+  if (evidence.length === 0) {
+    return closed(ruleId, "Tool durations within timeout.");
+  }
+  return open2(ruleId, "Tool call exceeded configured timeout.", evidence, "warning");
+}
+function evaluateRunawayLlmLoop(events, maxLlmCalls) {
+  const ruleId = "circuit.runaway-llm-loop";
+  const llmCount = events.filter(isLlmEvent).length;
+  const hasTerminal = events.some((event) => {
+    const status = (event.status ?? event.attributes?.status ?? "").toString().toLowerCase();
+    return status === "ok" || status === "success" || status === "completed";
+  });
+  if (llmCount <= maxLlmCalls || hasTerminal) {
+    return closed(ruleId, "LLM call count within threshold or run completed.");
+  }
+  return open2(ruleId, "Runaway LLM loop detected.", [
+    { ruleId, count: llmCount, threshold: maxLlmCalls }
+  ]);
+}
+function evaluateExcessiveBranchWidth(events, maxWidth) {
+  const ruleId = "circuit.excessive-branch-width";
+  const children = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const parentId = event.parentId;
+    if (!parentId) continue;
+    children.set(parentId, (children.get(parentId) ?? 0) + 1);
+  }
+  const evidence = [];
+  for (const [parentId, count] of children) {
+    if (count > maxWidth) {
+      evidence.push({ ruleId, path: parentId, count, threshold: maxWidth });
+    }
+  }
+  if (evidence.length === 0) {
+    return closed(ruleId, "Branch width within threshold.");
+  }
+  return open2(ruleId, "Excessive parallel branch width detected.", evidence, "warning");
+}
+function runRule(ruleId, events, options) {
+  switch (ruleId) {
+    case "circuit.same-tool-repetition":
+      if (options.sameToolRepetition === void 0) return void 0;
+      return evaluateSameToolRepetition(events, options.sameToolRepetition.maxRepeats);
+    case "circuit.same-args-repetition":
+      if (options.sameArgsRepetition === void 0) return void 0;
+      return evaluateSameArgsRepetition(events, options.sameArgsRepetition.maxRepeats);
+    case "circuit.max-loop-iterations":
+      if (options.maxLoopIterations === void 0) return void 0;
+      return evaluateMaxLoopIterations(events, options.maxLoopIterations.maxIterations);
+    case "circuit.max-retries":
+      if (options.maxRetries === void 0) return void 0;
+      return evaluateMaxRetries(events, options.maxRetries.maxRetries);
+    case "circuit.tool-timeout":
+      if (options.toolTimeout === void 0) return void 0;
+      return evaluateToolTimeout(events, options.toolTimeout.maxDurationMs);
+    case "circuit.runaway-llm-loop":
+      if (options.runawayLlmLoop === void 0) return void 0;
+      return evaluateRunawayLlmLoop(events, options.runawayLlmLoop.maxLlmCalls);
+    case "circuit.excessive-branch-width":
+      if (options.excessiveBranchWidth === void 0) return void 0;
+      return evaluateExcessiveBranchWidth(events, options.excessiveBranchWidth.maxWidth);
+    default:
+      return void 0;
+  }
+}
+function runCircuits(events, options = {}) {
+  const selected = options.rules ?? ALL_RULES;
+  const results = [];
+  for (const ruleId of selected) {
+    const result = runRule(ruleId, events, options);
+    if (result) results.push(result);
+  }
+  const ok = !results.some((result) => result.status === "open" && result.severity === "error");
+  return { ok, results };
+}
+
+// packages/guardrails/src/rules.ts
+var DEFAULT_INJECTION_PATTERNS = [
+  "ignore previous instructions",
+  "ignore all prior",
+  "disregard your instructions",
+  "system prompt",
+  "you are now",
+  "jailbreak"
+];
+function pass(ruleId, message) {
+  return { ruleId, status: "pass", severity: "info", message, evidence: [] };
+}
+function fail(ruleId, message, evidence, severity = "error") {
+  return { ruleId, status: severity === "warning" ? "warn" : "fail", severity, message, evidence };
+}
+function boundedPreview(value, max = 80) {
+  if (value.length <= max) return value;
+  return `${value.slice(0, max - 3)}...`;
+}
+function evaluateBannedPhrase(text, options) {
+  const ruleId = "guardrail.banned-phrase";
+  const haystack = options.caseInsensitive !== false ? text.toLowerCase() : text;
+  const evidence = [];
+  for (const phrase of options.phrases) {
+    const needle = options.caseInsensitive !== false ? phrase.toLowerCase() : phrase;
+    if (needle.length > 0 && haystack.includes(needle)) {
+      evidence.push({ ruleId, match: phrase, preview: boundedPreview(text) });
+    }
+  }
+  if (evidence.length === 0) {
+    return pass(ruleId, "No banned phrases matched.");
+  }
+  return fail(ruleId, `Matched ${evidence.length} banned phrase(s).`, evidence);
+}
+var SEVERITY_RANK2 = { info: 0, warning: 1, error: 2 };
+function evaluatePiiLeak(value, options = {}) {
+  const ruleId = "guardrail.pii-leak";
+  const minSeverity = options.minSeverity ?? "warning";
+  const result = redact(value, { profile: options.profile ?? "share", collectFindings: true });
+  const findings = result.findings.filter(
+    (finding) => SEVERITY_RANK2[finding.severity] >= SEVERITY_RANK2[minSeverity]
+  );
+  if (findings.length === 0) {
+    return pass(ruleId, "No PII-style redaction findings.");
+  }
+  const evidence = findings.map((finding) => ({
+    ruleId,
+    path: finding.path,
+    detector: finding.detector,
+    preview: finding.preview
+  }));
+  return fail(ruleId, `Detected ${findings.length} PII-style finding(s).`, evidence);
+}
+function measureDepth(value) {
+  if (value === null || typeof value !== "object") return 0;
+  if (Array.isArray(value)) {
+    return 1 + Math.max(0, ...value.map((item) => measureDepth(item)));
+  }
+  const depths = Object.values(value).map((item) => measureDepth(item));
+  return 1 + (depths.length === 0 ? 0 : Math.max(...depths));
+}
+function maxStringLength(value) {
+  if (typeof value === "string") return value.length;
+  if (value === null || typeof value !== "object") return 0;
+  if (Array.isArray(value)) {
+    return Math.max(0, ...value.map((item) => maxStringLength(item)));
+  }
+  return Math.max(0, ...Object.values(value).map((item) => maxStringLength(item)));
+}
+function evaluateUnsafeToolArgs(toolName2, toolArgs2, options = {}) {
+  const ruleId = "guardrail.unsafe-tool-args";
+  const blocked = new Set((options.blockedTools ?? []).map((name) => name.toLowerCase()));
+  const evidence = [];
+  if (blocked.has(toolName2.toLowerCase())) {
+    evidence.push({ ruleId, preview: toolName2, match: toolName2 });
+  }
+  const maxDepth = options.maxDepth ?? 12;
+  const depth = measureDepth(toolArgs2);
+  if (depth > maxDepth) {
+    evidence.push({ ruleId, path: "args", preview: `depth=${depth}` });
+  }
+  const maxLen = options.maxStringLength ?? 16384;
+  const longest = maxStringLength(toolArgs2);
+  if (longest > maxLen) {
+    evidence.push({ ruleId, path: "args", preview: `maxStringLength=${longest}` });
+  }
+  if (evidence.length === 0) {
+    return pass(ruleId, "Tool arguments within configured bounds.");
+  }
+  return fail(ruleId, "Unsafe or oversized tool arguments detected.", evidence);
+}
+function evaluatePromptInjection(text, options = {}) {
+  const ruleId = "guardrail.prompt-injection";
+  const patterns = options.patterns ?? DEFAULT_INJECTION_PATTERNS;
+  const haystack = text.toLowerCase();
+  const evidence = [];
+  for (const pattern of patterns) {
+    const needle = pattern.toLowerCase();
+    if (needle.length > 0 && haystack.includes(needle)) {
+      evidence.push({ ruleId, match: pattern, preview: boundedPreview(text) });
+    }
+  }
+  if (evidence.length === 0) {
+    return pass(ruleId, "No prompt-injection patterns matched.");
+  }
+  return fail(ruleId, `Matched ${evidence.length} injection pattern(s).`, evidence, "warning");
+}
+function validateSchemaField(value, field, path16, evidence) {
+  const ruleId = "guardrail.structured-output";
+  if (field.type) {
+    const actual = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+    if (actual !== field.type) {
+      evidence.push({ ruleId, path: path16, preview: `expected ${field.type}, got ${actual}` });
+      return;
+    }
+  }
+  if (field.enum && !field.enum.some((item) => Object.is(item, value))) {
+    evidence.push({ ruleId, path: path16, preview: "value not in enum" });
+  }
+  if (field.type === "object" && field.required && value && typeof value === "object" && !Array.isArray(value)) {
+    const record = value;
+    for (const key of field.required) {
+      if (!(key in record)) {
+        evidence.push({ ruleId, path: `${path16}.${key}`, preview: "missing required key" });
+      }
+    }
+  }
+}
+function evaluateStructuredOutput(value, options) {
+  const ruleId = "guardrail.structured-output";
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return fail(ruleId, "Structured output must be an object.", [
+      { ruleId, preview: typeof value }
+    ]);
+  }
+  const record = value;
+  const evidence = [];
+  for (const [key, field] of Object.entries(options.schema)) {
+    validateSchemaField(record[key], field, key, evidence);
+  }
+  if (evidence.length === 0) {
+    return pass(ruleId, "Structured output matches schema subset.");
+  }
+  return fail(ruleId, "Structured output schema violation.", evidence);
+}
+function evaluateOversizeOutput(value, options = {}) {
+  const ruleId = "guardrail.oversize-output";
+  const text = typeof value === "string" ? value : JSON.stringify(value);
+  const maxLength = options.maxLength ?? options.maxSerializedLength ?? 32768;
+  if (text.length <= maxLength) {
+    return pass(ruleId, "Output within size limits.");
+  }
+  return fail(ruleId, `Output exceeds max length (${text.length} > ${maxLength}).`, [
+    { ruleId, preview: `length=${text.length}` }
+  ]);
+}
+function evaluateRequiredJsonShape(value, options) {
+  const ruleId = "guardrail.required-json-shape";
+  let parsed = value;
+  if (typeof value === "string") {
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      return fail(ruleId, "Value is not valid JSON.", [{ ruleId, preview: boundedPreview(value) }]);
+    }
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return fail(ruleId, "JSON value must be an object.", [{ ruleId, preview: typeof parsed }]);
+  }
+  const record = parsed;
+  const evidence = [];
+  for (const key of options.requiredKeys) {
+    if (!(key in record)) {
+      evidence.push({ ruleId, path: key, preview: "missing required key" });
+    }
+  }
+  if (evidence.length === 0) {
+    return pass(ruleId, "Required JSON keys present.");
+  }
+  return fail(ruleId, "Missing required JSON keys.", evidence);
+}
+
+// packages/guardrails/src/run.ts
+var ALL_RULES2 = [
+  "guardrail.banned-phrase",
+  "guardrail.pii-leak",
+  "guardrail.unsafe-tool-args",
+  "guardrail.prompt-injection",
+  "guardrail.structured-output",
+  "guardrail.oversize-output",
+  "guardrail.required-json-shape"
+];
+function isErrorFailure(result) {
+  return result.status === "fail" && result.severity === "error";
+}
+function runRule2(ruleId, input3, options) {
+  switch (ruleId) {
+    case "guardrail.banned-phrase": {
+      if (!options.bannedPhrase || input3.text === void 0) return void 0;
+      return evaluateBannedPhrase(input3.text, options.bannedPhrase);
+    }
+    case "guardrail.pii-leak": {
+      if (input3.value === void 0 && input3.text === void 0) return void 0;
+      return evaluatePiiLeak(input3.value ?? input3.text, options.piiLeak);
+    }
+    case "guardrail.unsafe-tool-args": {
+      if (!input3.toolName) return void 0;
+      return evaluateUnsafeToolArgs(input3.toolName, input3.toolArgs ?? {}, options.unsafeToolArgs);
+    }
+    case "guardrail.prompt-injection": {
+      if (input3.text === void 0) return void 0;
+      return evaluatePromptInjection(input3.text, options.promptInjection);
+    }
+    case "guardrail.structured-output": {
+      if (!options.structuredOutput || input3.value === void 0) return void 0;
+      return evaluateStructuredOutput(input3.value, options.structuredOutput);
+    }
+    case "guardrail.oversize-output": {
+      if (input3.value === void 0 && input3.text === void 0) return void 0;
+      return evaluateOversizeOutput(input3.value ?? input3.text, options.oversizeOutput);
+    }
+    case "guardrail.required-json-shape": {
+      if (!options.requiredJsonShape || input3.value === void 0 && input3.text === void 0) return void 0;
+      return evaluateRequiredJsonShape(input3.value ?? input3.text, options.requiredJsonShape);
+    }
+    default:
+      return void 0;
+  }
+}
+function runGuardrails(input3, options = {}) {
+  const selected = options.rules ?? ALL_RULES2;
+  const results = [];
+  for (const ruleId of selected) {
+    const result = runRule2(ruleId, input3, options);
+    if (result) results.push(result);
+  }
+  const ok = !results.some(isErrorFailure);
+  return { ok, results };
+}
+
+// packages/cli/src/safety-extensions.ts
+var GUARDRAIL_ALIASES = {
+  "banned-phrase": "guardrail.banned-phrase",
+  "pii-leak": "guardrail.pii-leak",
+  "unsafe-tool-args": "guardrail.unsafe-tool-args",
+  "prompt-injection": "guardrail.prompt-injection",
+  "structured-output": "guardrail.structured-output",
+  "oversize-output": "guardrail.oversize-output",
+  "required-json-shape": "guardrail.required-json-shape"
+};
+var CIRCUIT_ALIASES = {
+  "same-tool-repetition": "circuit.same-tool-repetition",
+  "same-args-repetition": "circuit.same-args-repetition",
+  "max-loop-iterations": "circuit.max-loop-iterations",
+  "max-retries": "circuit.max-retries",
+  "tool-timeout": "circuit.tool-timeout",
+  "runaway-llm-loop": "circuit.runaway-llm-loop",
+  "excessive-branch-width": "circuit.excessive-branch-width"
+};
+function parseGuardrailRules(values) {
+  if (!values?.length) return void 0;
+  return values.map((value) => {
+    const rule = GUARDRAIL_ALIASES[value] ?? value;
+    return rule;
+  });
+}
+function parseCircuitRules(values) {
+  if (!values?.length) return void 0;
+  return values.map((value) => {
+    const rule = CIRCUIT_ALIASES[value] ?? value;
+    return rule;
+  });
+}
+function toSeverity(severity) {
+  return severity;
+}
+function guardrailFinding(result) {
+  return {
+    ruleId: result.ruleId,
+    severity: toSeverity(result.severity),
+    status: result.status === "pass" ? "pass" : result.status === "warn" ? "warning" : "fail",
+    message: result.message,
+    evidence: result.evidence.map(
+      (item) => ({
+        path: item.preview ? `${item.path ?? "value"} (${item.preview})` : item.path
+      })
+    )
+  };
+}
+function circuitFinding(result) {
+  return {
+    ruleId: result.ruleId,
+    severity: toSeverity(result.severity),
+    status: result.status === "closed" ? "pass" : result.status === "warn" ? "warning" : "fail",
+    message: result.message,
+    evidence: result.evidence.map(
+      (item) => ({
+        runId: item.runId,
+        eventId: item.eventId,
+        path: item.path,
+        name: item.toolName
+      })
+    ),
+    actual: result.evidence[0]?.count,
+    expected: result.evidence[0]?.threshold
+  };
+}
+function eventToCircuit(event) {
+  return {
+    eventId: event.eventId,
+    runId: event.runId,
+    name: event.name,
+    kind: event.kind,
+    parentId: event.parentId,
+    startedAt: event.startedAt,
+    endedAt: event.endedAt,
+    durationMs: event.durationMs,
+    attributes: event.attributes,
+    status: event.status
+  };
+}
+function collectGuardrailInputs(read) {
+  const inputs = [];
+  for (const event of read.events) {
+    const attrs = event.attributes ?? {};
+    for (const key of ["output", "answer", "text", "content", "message"]) {
+      const value = attrs[key];
+      if (typeof value === "string") inputs.push({ text: value });
+      else if (value !== void 0) inputs.push({ value });
+    }
+    if (event.kind === "TOOL" || event.name.startsWith("tool:")) {
+      inputs.push({
+        toolName: String(attrs.toolName ?? attrs.tool ?? event.name),
+        toolArgs: attrs.arguments ?? attrs.args ?? attrs.input
+      });
+    }
+  }
+  return inputs;
+}
+var DEFAULT_GUARDRAIL_OPTIONS = {
+  bannedPhrase: { phrases: ["delete all data", "ignore all instructions"] },
+  promptInjection: {},
+  piiLeak: { profile: "share" }
+};
+var DEFAULT_CIRCUIT_OPTIONS = {
+  sameToolRepetition: { maxRepeats: 3 },
+  sameArgsRepetition: { maxRepeats: 2 },
+  maxLoopIterations: { maxIterations: 20 },
+  maxRetries: { maxRetries: 3 },
+  toolTimeout: { maxDurationMs: 6e4 },
+  runawayLlmLoop: { maxLlmCalls: 12 },
+  excessiveBranchWidth: { maxWidth: 8 }
+};
+function mergeSafetyExtensions(result, read, options) {
+  const findings = [...result.findings];
+  let failed = result.summary.failed;
+  let warnings = result.summary.warnings;
+  let passed = result.summary.passed;
+  const guardrailRules = parseGuardrailRules(options.guardrails);
+  if (guardrailRules) {
+    for (const input3 of collectGuardrailInputs(read)) {
+      const run = runGuardrails(input3, {
+        ...DEFAULT_GUARDRAIL_OPTIONS,
+        rules: guardrailRules
+      });
+      for (const item of run.results) {
+        const finding = guardrailFinding(item);
+        findings.push(finding);
+        if (finding.status === "fail") failed += 1;
+        else if (finding.status === "warning") warnings += 1;
+        else passed += 1;
+      }
+    }
+  }
+  const circuitRules = parseCircuitRules(options.circuits);
+  if (circuitRules) {
+    const circuitRun = runCircuits(
+      read.events.map(eventToCircuit),
+      { ...DEFAULT_CIRCUIT_OPTIONS, rules: circuitRules }
+    );
+    for (const item of circuitRun.results) {
+      const finding = circuitFinding(item);
+      findings.push(finding);
+      if (finding.status === "fail") failed += 1;
+      else if (finding.status === "warning") warnings += 1;
+      else passed += 1;
+    }
+  }
+  const ok = failed === 0 && result.summary.errors === 0;
+  return {
+    ...result,
+    ok,
+    status: failed > 0 ? "fail" : result.status,
+    summary: {
+      passed,
+      failed,
+      warnings,
+      errors: result.summary.errors
+    },
+    findings
+  };
+}
 
 // packages/cli/src/check.ts
 var DEFAULT_SELECT = ["run.status"];
@@ -11494,7 +12110,7 @@ function asConfig(value) {
 }
 async function loadConfig(configPath) {
   if (configPath === void 0) return {};
-  const extension = path13.extname(configPath);
+  const extension = path14.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."
@@ -11503,7 +12119,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 = path13.resolve(configPath);
+  const absolute = path14.resolve(configPath);
   if (extension === ".json") {
     const raw = await readFile(absolute, "utf-8");
     return asConfig(JSON.parse(raw));
@@ -11632,10 +12248,10 @@ function printHuman(result) {
     console.log(`- ${diagnostic4.code}: ${diagnostic4.message}`);
   }
   for (const finding of result.findings) {
-    const path15 = finding.evidence[0]?.path;
+    const path16 = finding.evidence[0]?.path;
     const run = finding.evidence[0]?.runId;
     const runPrefix = run ? `[${run}] ` : "";
-    console.log(`- ${runPrefix}${finding.ruleId}: ${finding.message}${path15 ? ` (${path15})` : ""}`);
+    console.log(`- ${runPrefix}${finding.ruleId}: ${finding.message}${path16 ? ` (${path16})` : ""}`);
   }
 }
 function readErrorResult(error) {
@@ -11685,12 +12301,19 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
           }
         );
         perRun.push(
-          runTraceChecks(
-            { read },
+          mergeSafetyExtensions(
+            runTraceChecks(
+              { read },
+              {
+                rules: built.rules,
+                select: built.select,
+                runId: meta.runId
+              }
+            ),
+            read,
             {
-              rules: built.rules,
-              select: built.select,
-              runId: meta.runId
+              ...options.guardrails ? { guardrails: options.guardrails } : {},
+              ...options.circuit ? { circuits: options.circuit } : {}
             }
           )
         );
@@ -11709,12 +12332,19 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
       const read = await openTrace(input3, {
         ...options.format !== void 0 ? { format: options.format } : {}
       });
-      result = runTraceChecks(
-        { read },
+      result = mergeSafetyExtensions(
+        runTraceChecks(
+          { read },
+          {
+            rules: built.rules,
+            select: built.select,
+            ...options.run !== void 0 ? { runId: options.run } : {}
+          }
+        ),
+        read,
         {
-          rules: built.rules,
-          select: built.select,
-          ...options.run !== void 0 ? { runId: options.run } : {}
+          ...options.guardrails ? { guardrails: options.guardrails } : {},
+          ...options.circuit ? { circuits: options.circuit } : {}
         }
       );
     }
@@ -11735,6 +12365,262 @@ async function checkCommand(target, options = {}, stdin = process.stdin) {
   else printHuman(result);
 }
 
+// packages/viewer/src/html.ts
+var viewerIndexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>AgentInspect Viewer</title>
+  <style>
+    body { font-family: system-ui, sans-serif; margin: 1.5rem; line-height: 1.4; }
+    h1 { font-size: 1.25rem; }
+    pre { background: #f4f4f5; padding: 1rem; overflow: auto; max-height: 70vh; }
+    a { color: #0b57d0; }
+    .muted { color: #666; }
+  </style>
+</head>
+<body>
+  <h1>AgentInspect local viewer</h1>
+  <p class="muted">Read-only. JSONL on disk remains canonical.</p>
+  <p><a href="/api/health">/api/health</a> \xB7 <a href="/api/traces">/api/traces</a> \xB7 <a href="/api/sessions">/api/sessions</a></p>
+  <pre id="out">Loading traces\u2026</pre>
+  <script>
+    fetch("/api/traces").then((r) => r.json()).then((data) => {
+      document.getElementById("out").textContent = JSON.stringify(data, null, 2);
+    }).catch((err) => {
+      document.getElementById("out").textContent = String(err);
+    });
+  </script>
+</body>
+</html>
+`;
+
+// packages/viewer/src/server.ts
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 7337;
+var DEFAULT_MAX_EVENTS = 500;
+function sendJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store"
+  });
+  res.end(payload);
+}
+function notFound(res, message) {
+  sendJson(res, 404, { error: message });
+}
+function badRequest(res, message) {
+  sendJson(res, 400, { error: message });
+}
+function decodeId(segment) {
+  if (!segment) return "";
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function boundedEvents(events, maxEvents) {
+  if (events.length <= maxEvents) return [...events];
+  return events.slice(0, maxEvents);
+}
+function createViewerServer(options = {}) {
+  const traceDir = resolveTraceDir({ dir: options.traceDir });
+  const host = options.host ?? DEFAULT_HOST;
+  const port = options.port ?? DEFAULT_PORT;
+  const maxEvents = options.maxEvents ?? DEFAULT_MAX_EVENTS;
+  if (host === "0.0.0.0") {
+    console.warn(
+      "[AgentInspect viewer] Binding to 0.0.0.0 exposes traces on the network. Use 127.0.0.1 unless you accept that risk."
+    );
+  }
+  const server = createServer(async (req, res) => {
+    try {
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        return badRequest(res, "Only GET is supported.");
+      }
+      const url = new URL(req.url ?? "/", `http://${host}:${port}`);
+      const pathname = url.pathname;
+      if (pathname === "/" || pathname === "/index.html") {
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        res.end(viewerIndexHtml);
+        return;
+      }
+      if (pathname === "/api/health") {
+        return sendJson(res, 200, {
+          ok: true,
+          readOnly: true,
+          traceDir: path14.resolve(traceDir)
+        });
+      }
+      const td = new TraceDirectory({ dir: traceDir });
+      if (pathname === "/api/traces") {
+        const files = await td.list();
+        const metas = await loadTraceMetadataList(
+          traceDir,
+          files,
+          (fileName) => td.getPath(fileName)
+        );
+        return sendJson(
+          res,
+          200,
+          metas.map((meta) => ({
+            runId: meta.runId,
+            name: meta.name,
+            status: meta.status,
+            file: path14.basename(meta.filePath),
+            startedAt: meta.startedAt,
+            durationMs: meta.durationMs
+          }))
+        );
+      }
+      if (pathname === "/api/sessions") {
+        const files = await td.list();
+        const metas = await loadTraceMetadataList(
+          traceDir,
+          files,
+          (fileName) => td.getPath(fileName)
+        );
+        const runs = await loadSessionRunRecords(metas);
+        const index = buildSessionIndex(runs, {
+          correlateByGroupId: url.searchParams.get("correlateGroup") === "true"
+        });
+        return sendJson(res, 200, index);
+      }
+      const sessionMatch = pathname.match(/^\/api\/session\/([^/]+)$/);
+      if (sessionMatch) {
+        const sessionId = decodeId(sessionMatch[1]);
+        const files = await td.list();
+        const metas = await loadTraceMetadataList(
+          traceDir,
+          files,
+          (fileName) => td.getPath(fileName)
+        );
+        const runs = await loadSessionRunRecords(metas);
+        const index = buildSessionIndex(runs, {
+          correlateByGroupId: url.searchParams.get("correlateGroup") === "true"
+        });
+        const session = index.sessions.find((item) => item.sessionId === sessionId);
+        if (!session) return notFound(res, `Session not found: ${sessionId}`);
+        return sendJson(res, 200, session);
+      }
+      const traceMatch = pathname.match(/^\/api\/trace\/([^/]+)$/);
+      if (traceMatch) {
+        const runId = decodeId(traceMatch[1]);
+        const files = await td.list();
+        const metas = await loadTraceMetadataList(
+          traceDir,
+          files,
+          (fileName) => td.getPath(fileName)
+        );
+        const meta = metas.find((item) => item.runId === runId);
+        if (!meta) return notFound(res, `Run not found: ${runId}`);
+        const read = await openTrace({ type: "file", path: meta.filePath });
+        const run = read.runs.find((item) => item.runId === runId) ?? read.runs[0];
+        return sendJson(res, 200, {
+          runId,
+          format: read.format,
+          run,
+          events: boundedEvents(read.events, maxEvents),
+          warnings: read.warnings,
+          truncated: read.events.length > maxEvents
+        });
+      }
+      const timelineMatch = pathname.match(/^\/api\/trace\/([^/]+)\/timeline$/);
+      if (timelineMatch) {
+        const runId = decodeId(timelineMatch[1]);
+        const files = await td.list();
+        const metas = await loadTraceMetadataList(
+          traceDir,
+          files,
+          (fileName) => td.getPath(fileName)
+        );
+        const meta = metas.find((item) => item.runId === runId);
+        if (!meta) return notFound(res, `Run not found: ${runId}`);
+        const read = await openTrace({ type: "file", path: meta.filePath });
+        const legacyEvents = persistedInspectEventsToTraceEvents(
+          boundedEvents(read.events, maxEvents)
+        );
+        const timeline = buildRunTimeline(legacyEvents, { focus: "all" });
+        return sendJson(res, 200, { runId, timeline });
+      }
+      const checkMatch = pathname.match(/^\/api\/trace\/([^/]+)\/check$/);
+      if (checkMatch) {
+        const runId = decodeId(checkMatch[1]);
+        const files = await td.list();
+        const metas = await loadTraceMetadataList(
+          traceDir,
+          files,
+          (fileName) => td.getPath(fileName)
+        );
+        const meta = metas.find((item) => item.runId === runId);
+        if (!meta) return notFound(res, `Run not found: ${runId}`);
+        const read = await openTrace({ type: "file", path: meta.filePath });
+        const result = runTraceChecks(
+          { read },
+          { rules: [createRunStatusRule()], select: ["run.status"], runId }
+        );
+        return sendJson(res, 200, result);
+      }
+      return notFound(res, `Unknown route: ${pathname}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      sendJson(res, 500, { error: message });
+    }
+  });
+  return server;
+}
+function startViewerServer(options = {}) {
+  const host = options.host ?? DEFAULT_HOST;
+  const port = options.port ?? DEFAULT_PORT;
+  const traceDir = resolveTraceDir({ dir: options.traceDir });
+  const server = createViewerServer(options);
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      const address = server.address();
+      const resolvedPort = typeof address === "object" && address ? address.port : port;
+      resolve({
+        host,
+        port: resolvedPort,
+        traceDir: path14.resolve(traceDir),
+        url: `http://${host}:${resolvedPort}`
+      });
+    });
+  });
+}
+
+// packages/cli/src/serve.ts
+function parsePort(value) {
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+    throw new Error("--port must be an integer between 1 and 65535.");
+  }
+  return parsed;
+}
+async function serveCommand(options = {}) {
+  const port = parsePort(options.port);
+  const host = options.host?.trim() || "127.0.0.1";
+  const info = await startViewerServer({
+    ...options.dir !== void 0 ? { traceDir: options.dir } : {},
+    host,
+    ...port !== void 0 ? { port } : {}
+  });
+  console.log(`AgentInspect viewer (read-only): ${info.url}`);
+  console.log(`Trace directory: ${info.traceDir}`);
+  if (options.open === true && host !== "127.0.0.1" && host !== "localhost") {
+    console.warn("Skipping browser open for non-local host binding.");
+  } else if (options.open === true) {
+    const openMod = await import('child_process');
+    openMod.exec(`open ${info.url}`, () => {
+    });
+  }
+  await new Promise(() => {
+  });
+}
+
 // packages/eval/src/index.ts
 function isTraceReadResult(value) {
   return value !== null && typeof value === "object" && "runs" in value && "events" in value && "format" in value;
@@ -11903,10 +12789,10 @@ async function evalRun(input3, options = {}) {
     diagnostics: []
   };
 }
-function evidenceForRun(run, path15) {
-  return [{ runId: run.runId, ...path15 !== void 0 ? { path: path15 } : {} }];
+function evidenceForRun(run, path16) {
+  return [{ runId: run.runId, ...path16 !== void 0 ? { path: path16 } : {} }];
 }
-function evidenceForEvent(event, path15) {
+function evidenceForEvent(event, path16) {
   return [
     {
       runId: event.runId,
@@ -11914,11 +12800,11 @@ function evidenceForEvent(event, path15) {
       ...event.parentId !== void 0 ? { parentId: event.parentId } : {},
       kind: event.kind,
       name: event.name,
-      ...path15 !== void 0 ? { path: path15 } : {}
+      ...path16 !== void 0 ? { path: path16 } : {}
     }
   ];
 }
-function fail(ruleId, message, evidence, expected, actual) {
+function fail2(ruleId, message, evidence, expected, actual) {
   return {
     ruleId,
     status: "fail",
@@ -12072,9 +12958,9 @@ function collectTextFields(nodes, keys, preferredKinds = []) {
 function tokenize(text) {
   return [...text.toLowerCase().matchAll(/[a-z0-9][a-z0-9'-]{2,}/g)].map((match) => match[0].replace(/^['-]+|['-]+$/g, "")).filter((token) => token.length > 2 && !STOP_WORDS.has(token));
 }
-function firstEvidence(fields, run, path15) {
+function firstEvidence(fields, run, path16) {
   const first = fields[0];
-  return first === void 0 ? evidenceForRun(run, path15) : evidenceForEvent(first.node.event, first.path);
+  return first === void 0 ? evidenceForRun(run, path16) : evidenceForEvent(first.node.event, first.path);
 }
 function collectSourceIds(nodes, keys) {
   const wanted = keySet(keys);
@@ -12114,7 +13000,7 @@ var checks = {
       "eval.requireSuccess",
       "run",
       (context) => context.run.status === "ok" ? [] : [
-        fail(
+        fail2(
           "eval.requireSuccess",
           "Run did not complete successfully.",
           evidenceForRun(context.run, "status"),
@@ -12129,7 +13015,7 @@ var checks = {
     return createRule("eval.requiredTools", "tool", (context) => {
       const tools = new Set(nodeNames(context.nodes, "TOOL"));
       return expected.filter((name) => !tools.has(name)).map(
-        (name) => fail(
+        (name) => fail2(
           "eval.requiredTools",
           `Required tool ${name} did not appear.`,
           evidenceForRun(context.run, "children"),
@@ -12145,7 +13031,7 @@ var checks = {
       "eval.forbiddenTools",
       "tool",
       (context) => context.nodes.filter((node) => node.event.kind === "TOOL" && blocked.includes(node.event.name)).map(
-        (node) => fail(
+        (node) => fail2(
           "eval.forbiddenTools",
           `Forbidden tool ${node.event.name} appeared.`,
           evidenceForEvent(node.event, "name"),
@@ -12160,7 +13046,7 @@ var checks = {
       "eval.maxDurationMs",
       "run",
       (context) => context.run.durationMs !== void 0 && context.run.durationMs > maxDurationMs ? [
-        fail(
+        fail2(
           "eval.maxDurationMs",
           `Run duration exceeded ${maxDurationMs}ms.`,
           evidenceForRun(context.run, "durationMs"),
@@ -12177,7 +13063,7 @@ var checks = {
         void 0
       );
       return deepest !== void 0 && deepest.depth > maxDepth ? [
-        fail(
+        fail2(
           "eval.maxDepth",
           `Run tree depth exceeded ${maxDepth}.`,
           evidenceForEvent(deepest.event, "depth"),
@@ -12194,7 +13080,7 @@ var checks = {
       (context) => context.nodes.flatMap((node) => {
         const retries = numericAttribute(node, ["retryCount", "retries", "attempt"]);
         return retries !== void 0 && retries > maxRetries ? [
-          fail(
+          fail2(
             "eval.maxRetries",
             `Retry count exceeded ${maxRetries}.`,
             evidenceForEvent(node.event, "attributes.retryCount"),
@@ -12209,7 +13095,7 @@ var checks = {
     return createRule("eval.maxTotalTokens", "llm", (context) => {
       const total = totalTokenCount(context.events);
       return total > maxTotalTokens ? [
-        fail(
+        fail2(
           "eval.maxTotalTokens",
           `Total token usage exceeded ${maxTotalTokens}.`,
           evidenceForRun(context.run, "tokenUsage.total"),
@@ -12224,7 +13110,7 @@ var checks = {
       "eval.noFailedSteps",
       "run",
       (context) => context.nodes.filter((node) => node.event.status === "error" || node.event.kind === "ERROR").map(
-        (node) => fail(
+        (node) => fail2(
           "eval.noFailedSteps",
           "Run contains a failed step or error node.",
           evidenceForEvent(node.event, "status"),
@@ -12242,7 +13128,7 @@ var checks = {
         (node, index) => index < firstLlmIndex && node.event.kind === "RETRIEVER"
       );
       return retrievalIndex === -1 ? [
-        fail(
+        fail2(
           "eval.requiredRetrievalBeforeGeneration",
           "No retrieval step appeared before the first LLM generation.",
           evidenceForEvent(context.nodes[firstLlmIndex].event, "kind"),
@@ -12258,7 +13144,7 @@ var checks = {
       const decisions = context.nodes.filter((node) => node.event.kind === "DECISION");
       if (decisions.length === 0) {
         return [
-          fail(
+          fail2(
             "eval.requiredDecisionMetadata",
             "No decision node is available for required metadata.",
             evidenceForRun(context.run, "children"),
@@ -12269,7 +13155,7 @@ var checks = {
       }
       return decisions.flatMap(
         (node) => required.filter((key) => !hasAttribute(node, key)).map(
-          (key) => fail(
+          (key) => fail2(
             "eval.requiredDecisionMetadata",
             `Decision metadata ${key} is missing.`,
             evidenceForEvent(node.event, `attributes.${key}`),
@@ -12290,7 +13176,7 @@ var checks = {
       const contexts = collectTextFields(context.nodes, contextKeys, ["RETRIEVER", "TOOL"]);
       if (answers.length === 0 || contexts.length === 0) {
         return [
-          fail(
+          fail2(
             "eval.contextOverlap",
             "Answer and context text are required for overlap evaluation.",
             firstEvidence(answers.length > 0 ? answers : contexts, context.run, "children"),
@@ -12304,7 +13190,7 @@ var checks = {
       const sharedTerms = [...answerTerms].filter((term) => contextTerms.has(term)).length;
       const overlap = answerTerms.size === 0 ? 0 : sharedTerms / answerTerms.size;
       return sharedTerms < minSharedTerms || overlap < minOverlap ? [
-        fail(
+        fail2(
           "eval.contextOverlap",
           "Answer text did not sufficiently overlap retrieved context.",
           firstEvidence(answers, context.run, "attributes.answer"),
@@ -12332,7 +13218,7 @@ var checks = {
       const quotes = quotedSnippets(answerText, minQuoteLength);
       if (quotes.length === 0) {
         return requireQuote ? [
-          fail(
+          fail2(
             "eval.quoteOverlap",
             "Answer did not contain a quote for overlap evaluation.",
             firstEvidence(answers, context.run, "attributes.answer"),
@@ -12343,7 +13229,7 @@ var checks = {
       }
       const missing = quotes.filter((quote) => !contextText.includes(quote.toLowerCase()));
       return missing.length > 0 ? [
-        fail(
+        fail2(
           "eval.quoteOverlap",
           "Quoted answer text did not appear in retrieved context.",
           firstEvidence(answers, context.run, "attributes.answer"),
@@ -12361,7 +13247,7 @@ var checks = {
       const citations = collectTextFields(context.nodes, citationKeys);
       const count = citationCount(answers.map((field) => field.text).join(" "), citations);
       return count === 0 ? [
-        fail(
+        fail2(
           "eval.citationPresence",
           "Answer did not include citations or source references.",
           firstEvidence(answers, context.run, "attributes.answer"),
@@ -12379,7 +13265,7 @@ var checks = {
       const availableSet = new Set(available);
       const missing = expected.filter((id) => !availableSet.has(id));
       return missing.length > 0 ? [
-        fail(
+        fail2(
           "eval.requiredSourceIds",
           "Required source IDs were not present in trace context or citations.",
           evidenceForRun(context.run, "children"),
@@ -12399,7 +13285,7 @@ var checks = {
       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(
+        fail2(
           "eval.answerLengthBounds",
           "Answer length fell outside required bounds.",
           firstEvidence(answers, context.run, "attributes.answer"),
@@ -12422,7 +13308,7 @@ var checks = {
       const answer = answers.map((field) => field.text).join(" ").toLowerCase();
       const matches = banned.filter((phrase) => answer.includes(phrase));
       return matches.length > 0 ? [
-        fail(
+        fail2(
           "eval.bannedUnsupportedPhrases",
           "Answer contained banned unsupported-answer phrasing.",
           firstEvidence(answers, context.run, "attributes.answer"),
@@ -12451,8 +13337,8 @@ function renderEvalMarkdown(result) {
   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})` : ""}`);
+      const path16 = finding.evidence[0]?.path;
+      lines.push(`- ${finding.ruleId}: ${finding.message}${path16 ? ` (${path16})` : ""}`);
     }
   }
   return `${lines.join("\n")}
@@ -12499,7 +13385,7 @@ function asConfig2(value) {
 }
 async function loadConfig2(configPath) {
   if (configPath === void 0) return {};
-  const extension = path13.extname(configPath);
+  const extension = path14.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."
@@ -12508,7 +13394,7 @@ async function loadConfig2(configPath) {
   if (!CONFIG_EXTENSIONS2.has(extension)) {
     throw new Error("Unsupported eval config extension. Use .json, .js, .mjs, or .cjs.");
   }
-  const absolute = path13.resolve(configPath);
+  const absolute = path14.resolve(configPath);
   if (extension === ".json") {
     const raw = await readFile(absolute, "utf-8");
     return asConfig2(JSON.parse(raw));
@@ -12645,8 +13531,8 @@ function printHuman2(result) {
     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})` : ""}`);
+    const path16 = finding.evidence[0]?.path;
+    console.log(`- ${finding.ruleId}: ${finding.message}${path16 ? ` (${path16})` : ""}`);
   }
 }
 function readErrorResult2(error) {
@@ -12800,7 +13686,7 @@ function invalidArgumentResult(command, error) {
   });
 }
 function buildSafetyRules(options) {
-  const maxStringLength = parseLimit3(options.maxStringLength, "--max-string-length") ?? DEFAULT_MAX_STRING_LENGTH;
+  const maxStringLength2 = parseLimit3(options.maxStringLength, "--max-string-length") ?? DEFAULT_MAX_STRING_LENGTH;
   const maxArrayLength = parseLimit3(options.maxArrayLength, "--max-array-length") ?? DEFAULT_MAX_ARRAY_LENGTH;
   const maxObjectKeys = parseLimit3(options.maxObjectKeys, "--max-object-keys") ?? DEFAULT_MAX_OBJECT_KEYS;
   const maxSerializedBytes = parseLimit3(options.maxSerializedBytes, "--max-serialized-bytes") ?? DEFAULT_MAX_SERIALIZED_BYTES;
@@ -12809,7 +13695,7 @@ function buildSafetyRules(options) {
     createSafetyRedactionRule(),
     createSafetySecretPatternRule(),
     createSafetyOversizedAttributeRule({
-      maxStringLength,
+      maxStringLength: maxStringLength2,
       maxArrayLength,
       maxObjectKeys,
       maxSerializedBytes
@@ -12884,8 +13770,8 @@ function printHuman3(result) {
     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})` : ""}`);
+    const path16 = finding.evidence[0]?.path;
+    console.log(`- ${finding.ruleId}: ${finding.message}${path16 ? ` (${path16})` : ""}`);
   }
   console.log(`Note: ${result.note}`);
 }
@@ -13004,8 +13890,8 @@ function renderCheckSection(result) {
     `Diagnostics: ${result.diagnostics.length}`
   ];
   for (const finding of result.findings.slice(0, 10)) {
-    const path15 = finding.evidence[0]?.path ?? "(run)";
-    lines.push(`- ${finding.ruleId}: ${finding.message} (${path15})`);
+    const path16 = finding.evidence[0]?.path ?? "(run)";
+    lines.push(`- ${finding.ruleId}: ${finding.message} (${path16})`);
   }
   for (const diagnostic4 of result.diagnostics.slice(0, 10)) {
     lines.push(`- ${diagnostic4.code}: ${diagnostic4.message}`);
@@ -13083,8 +13969,8 @@ function renderHtml(trace, check, diff) {
 `;
 }
 async function writeArtifact(outputDir, relativePath, content, files) {
-  const outPath = path13.join(outputDir, relativePath);
-  await mkdir(path13.dirname(outPath), { recursive: true });
+  const outPath = path14.join(outputDir, relativePath);
+  await mkdir(path14.dirname(outPath), { recursive: true });
   await writeFile(outPath, content, "utf-8");
   files.push(relativePath);
 }
@@ -13100,7 +13986,7 @@ function manifestStatus(check, diff) {
   return "ok";
 }
 async function artifactsCommand(target, options = {}, stdin = process.stdin) {
-  const outputDir = options.outputDir !== void 0 && options.outputDir.trim() !== "" ? path13.resolve(options.outputDir.trim()) : "";
+  const outputDir = options.outputDir !== void 0 && options.outputDir.trim() !== "" ? path14.resolve(options.outputDir.trim()) : "";
   if (outputDir === "") {
     console.error("--output-dir is required.");
     process.exitCode = 1;
@@ -13166,8 +14052,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(path13.dirname(path13.resolve(summaryTarget)), { recursive: true });
-    await appendFile(path13.resolve(summaryTarget), `
+    await mkdir(path14.dirname(path14.resolve(summaryTarget)), { recursive: true });
+    await appendFile(path14.resolve(summaryTarget), `
 ${renderMarkdown(trace, check, diff)}`, "utf-8");
   }
   const manifestFiles = [...files, "manifest.json"].sort((a, b) => a.localeCompare(b));
@@ -13186,10 +14072,10 @@ ${renderMarkdown(trace, check, diff)}`, "utf-8");
       findings: diff?.findings.length ?? 0,
       diagnostics: diff?.diagnostics.length ?? 0
     },
-    ...summaryTarget !== void 0 && summaryTarget.trim() !== "" ? { githubSummary: path13.resolve(summaryTarget) } : {},
+    ...summaryTarget !== void 0 && summaryTarget.trim() !== "" ? { githubSummary: path14.resolve(summaryTarget) } : {},
     note: NOTE
   };
-  await writeFile(path13.join(outputDir, "manifest.json"), writeJson3(manifest), "utf-8");
+  await writeFile(path14.join(outputDir, "manifest.json"), writeJson3(manifest), "utf-8");
   if (options.json === true) {
     console.log(writeJson3(manifest).trimEnd());
   } else {
@@ -13201,7 +14087,7 @@ ${renderMarkdown(trace, check, diff)}`, "utf-8");
   }
 }
 function validateReporterArtifactPath(options) {
-  const outputDir = path13.resolve(options.outputDir);
+  const outputDir = path14.resolve(options.outputDir);
   const diagnostics = [];
   const rawPath = options.relativePath;
   if (rawPath.length === 0) {
@@ -13221,7 +14107,7 @@ function validateReporterArtifactPath(options) {
     });
     return { ok: false, outputDir, diagnostics };
   }
-  if (path13.isAbsolute(rawPath) || path13.win32.isAbsolute(rawPath)) {
+  if (path14.isAbsolute(rawPath) || path14.win32.isAbsolute(rawPath)) {
     diagnostics.push({
       code: "artifact_path_absolute",
       severity: "error",
@@ -13230,7 +14116,7 @@ function validateReporterArtifactPath(options) {
     });
     return { ok: false, outputDir, diagnostics };
   }
-  const normalized = path13.posix.normalize(rawPath.replace(/\\/g, "/"));
+  const normalized = path14.posix.normalize(rawPath.replace(/\\/g, "/"));
   const segments = normalized.split("/");
   if (normalized === "." || normalized.startsWith("../") || segments.some((segment) => segment === "..")) {
     diagnostics.push({
@@ -13241,9 +14127,9 @@ function validateReporterArtifactPath(options) {
     });
     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)) {
+  const absolutePath = path14.resolve(outputDir, normalized);
+  const relFromOutput = path14.relative(outputDir, absolutePath);
+  if (relFromOutput.length === 0 || relFromOutput.startsWith("..") || path14.isAbsolute(relFromOutput)) {
     diagnostics.push({
       code: "artifact_path_escape",
       severity: "error",
@@ -13389,23 +14275,23 @@ function readManifestDocument(value) {
   };
 }
 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);
+  const relative = path14.relative(process.cwd(), path14.resolve(filePath)).replace(/\\/g, "/");
+  if (relative === "" || relative.startsWith("../") || path14.isAbsolute(relative)) {
+    return path14.basename(filePath);
   }
   return relative;
 }
 async function readReporterManifest(filePath) {
-  const absolute = path13.resolve(filePath);
+  const absolute = path14.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)) },
+    ...result.file === void 0 ? {} : { file: safeText(path14.basename(result.file)) },
     status: result.status,
-    ...result.tracePath === void 0 ? {} : { tracePath: safeText(path13.basename(result.tracePath)) },
+    ...result.tracePath === void 0 ? {} : { tracePath: safeText(path14.basename(result.tracePath)) },
     artifacts: result.artifacts,
     diagnostics: result.diagnostics
   }));
@@ -13544,15 +14430,15 @@ async function ciSummaryCommand(manifestPaths, options = {}) {
     return;
   }
   const markdown = renderMarkdown2(result);
-  const outputPath = options.output !== void 0 && options.output.trim() !== "" ? path13.resolve(options.output.trim()) : void 0;
+  const outputPath = options.output !== void 0 && options.output.trim() !== "" ? path14.resolve(options.output.trim()) : void 0;
   if (outputPath !== void 0) {
-    await mkdir(path13.dirname(outputPath), { recursive: true });
+    await mkdir(path14.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 });
+    const summaryPath = path14.resolve(summaryTarget);
+    await mkdir(path14.dirname(summaryPath), { recursive: true });
     await appendFile(summaryPath, `
 ${markdown}`, "utf-8");
   }
@@ -13693,9 +14579,20 @@ function createCliProgram() {
   ]).option("--max-total-tokens <number>", "add llm.usage with a max total-token budget").option("--session <id>", "check all runs in a workflow session (requires --dir)").option("--group <id>", "check all runs sharing a groupId (requires --dir)").option(
     "--correlate-group",
     "when using --session, also match synthetic group: session keys"
+  ).option(
+    "--guardrails <rule>",
+    "run optional guardrail rules (repeatable): banned-phrase, pii-leak, prompt-injection, ...",
+    (value, previous = []) => [...previous, value]
+  ).option(
+    "--circuit <rule>",
+    "run optional circuit rules (repeatable): same-tool-repetition, max-retries, ...",
+    (value, previous = []) => [...previous, value]
   ).action((target, opts) => {
     runCommand(() => checkCommand(target, opts));
   });
+  program.command("serve").description("Start optional localhost read-only trace viewer").option("--dir <path>", "trace directory to serve").option("--host <host>", "bind host (default 127.0.0.1)", "127.0.0.1").option("--port <number>", "bind port (default 7337)", "7337").option("--open", "open browser locally when host is localhost").action((opts) => {
+    runCommand(() => serveCommand(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",
@@ -13860,9 +14757,9 @@ function isPrimaryModule() {
   if (!entry) return false;
   const selfPath = fileURLToPath(import.meta.url);
   try {
-    return realpathSync(path13.resolve(entry)) === realpathSync(path13.resolve(selfPath));
+    return realpathSync(path14.resolve(entry)) === realpathSync(path14.resolve(selfPath));
   } catch {
-    return path13.resolve(entry) === path13.resolve(selfPath);
+    return path14.resolve(entry) === path14.resolve(selfPath);
   }
 }
 if (isPrimaryModule()) {