@agent-inspect/viewer 6.9.0 → 6.11.0

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var http = require('http');
-var path13 = require('path');
+var path15 = require('path');
 var async_hooks = require('async_hooks');
 require('crypto');
 var promises = require('fs/promises');
@@ -14,7 +14,7 @@ var url = require('url');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var path13__default = /*#__PURE__*/_interopDefault(path13);
+var path15__default = /*#__PURE__*/_interopDefault(path15);
 var os__default = /*#__PURE__*/_interopDefault(os);
 
 // packages/viewer/src/server.ts
@@ -525,7 +525,7 @@ function persistedInspectEventsToTraceEvents(events, options) {
 }
 var DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
 var RUNS_DIR_NAME = "runs";
-var FALLBACK_TRACE_DIR = path13__default.default.join(
+var FALLBACK_TRACE_DIR = path15__default.default.join(
   os__default.default.tmpdir(),
   "agent-inspect",
   RUNS_DIR_NAME
@@ -540,7 +540,7 @@ function getDefaultTraceDir() {
     if (typeof home !== "string" || home.trim() === "") {
       return FALLBACK_TRACE_DIR;
     }
-    return path13__default.default.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
+    return path15__default.default.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
   } catch {
     return FALLBACK_TRACE_DIR;
   }
@@ -548,11 +548,11 @@ function getDefaultTraceDir() {
 function getTraceFilePath(runId, traceDir) {
   const baseDir = traceDir ?? getDefaultTraceDir();
   let safeId = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "run_unknown";
-  safeId = path13__default.default.basename(safeId);
+  safeId = path15__default.default.basename(safeId);
   if (safeId === "" || safeId === "." || safeId === "..") {
     safeId = "run_unknown";
   }
-  return path13__default.default.join(baseDir, `${safeId}.jsonl`);
+  return path15__default.default.join(baseDir, `${safeId}.jsonl`);
 }
 function formatError(error) {
   if (error instanceof Error) {
@@ -830,7 +830,7 @@ var TraceDirectory = class {
     this.#dir = resolveTraceDir(options);
   }
   getPath(filename) {
-    return filename ? path13__default.default.join(this.#dir, filename) : this.#dir;
+    return filename ? path15__default.default.join(this.#dir, filename) : this.#dir;
   }
   async list() {
     try {
@@ -857,7 +857,7 @@ function parseIsoToMs2(value) {
 }
 async function extractMetadata(filePath, _quickScan) {
   const stats = await promises.stat(filePath);
-  let runIdFromFile = path13__default.default.basename(filePath);
+  let runIdFromFile = path15__default.default.basename(filePath);
   if (runIdFromFile.endsWith(".jsonl")) {
     runIdFromFile = runIdFromFile.slice(0, -".jsonl".length);
   }
@@ -1467,12 +1467,12 @@ function buildCriticalPath(runs, handoffs) {
     handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.from)
   );
   const ordered = [...runs].sort(compareRuns);
-  const path16 = [];
+  const path18 = [];
   const visited = /* @__PURE__ */ new Set();
   const pushRun = (run, confidence, source) => {
     if (visited.has(run.runId)) return;
     visited.add(run.runId);
-    path16.push({
+    path18.push({
       runId: run.runId,
       name: run.name,
       startedAt: run.startedAt,
@@ -1497,7 +1497,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 path16;
+  return path18;
 }
 function metaRunIdMatches(run, token, runById) {
   const meta = extractSessionWorkflowMetadata(run.metadata);
@@ -1574,524 +1574,915 @@ function buildSessionIndex(inputRuns, options = {}) {
   };
 }
 
-// packages/core/src/suite/types.ts
-var DEFAULT_SUITE_CONFIG_NAMES = [
-  "agent-inspect.suite.json",
-  "agent-inspect.suite.js",
-  "agent-inspect.suite.mjs",
-  "agent-inspect.suite.cjs"
-];
-function diagnostic(code, message, severity = "error", caseId) {
-  return { code, message, severity, ...{} };
-}
-function asString(value, label) {
-  if (value === void 0) return void 0;
-  if (typeof value !== "string" || value.trim() === "") {
-    throw new Error(`${label} must be a non-empty string.`);
+// packages/core/src/exporters/helpers.ts
+function sortKeysDeep(input) {
+  if (input === null || typeof input !== "object") return input;
+  if (Array.isArray(input)) return input.map(sortKeysDeep);
+  const o = input;
+  const out = {};
+  for (const k of Object.keys(o).sort()) {
+    out[k] = sortKeysDeep(o[k]);
   }
-  return value.trim();
+  return out;
 }
-function asStringArray(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 stableJson(value, pretty) {
+  const sorted = sortKeysDeep(value);
+  return JSON.stringify(sorted);
 }
-function asPositiveNumber(value, label) {
-  if (value === void 0) return void 0;
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    throw new Error(`${label} must be a non-negative number.`);
-  }
-  return value;
+
+// packages/core/src/diff/comparable.ts
+function extractOutputPreview(meta) {
+  if (meta === void 0) return void 0;
+  if ("outputPreview" in meta) return meta.outputPreview;
+  if ("resultPreview" in meta) return meta.resultPreview;
+  return void 0;
 }
-function validateCaseConfig(value, index) {
-  const diagnostics = [];
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    diagnostics.push(
-      diagnostic("AI_SUITE_CONFIG_INVALID", `cases[${index}] must be an object.`)
-    );
-    return { diagnostics };
-  }
-  const raw = value;
-  try {
-    const id = asString(raw.id, `cases[${index}].id`);
-    if (id === void 0) {
-      diagnostics.push(
-        diagnostic("AI_SUITE_CONFIG_INVALID", `cases[${index}].id is required.`)
-      );
-      return { diagnostics };
-    }
-    const trace = asString(raw.trace, `cases[${index}].trace`);
-    const runId = asString(raw.runId, `cases[${index}].runId`);
-    const input = asString(raw.input, `cases[${index}].input`);
-    return {
-      caseConfig: {
-        id,
-        ...trace !== void 0 ? { trace } : {},
-        ...runId !== void 0 ? { runId } : {},
-        ...input !== void 0 ? { input } : {},
-        ...asStringArray(raw.requireTools, `cases[${index}].requireTools`) !== void 0 ? { requireTools: asStringArray(raw.requireTools, `cases[${index}].requireTools`) } : {},
-        ...asStringArray(raw.forbidTools, `cases[${index}].forbidTools`) !== void 0 ? { forbidTools: asStringArray(raw.forbidTools, `cases[${index}].forbidTools`) } : {},
-        ...asPositiveNumber(raw.maxDurationMs, `cases[${index}].maxDurationMs`) !== void 0 ? {
-          maxDurationMs: asPositiveNumber(
-            raw.maxDurationMs,
-            `cases[${index}].maxDurationMs`
-          )
-        } : {},
-        ...asStringArray(
-          raw.expectedObservations,
-          `cases[${index}].expectedObservations`
-        ) !== void 0 ? {
-          expectedObservations: asStringArray(
-            raw.expectedObservations,
-            `cases[${index}].expectedObservations`
-          )
-        } : {}
-      },
-      diagnostics
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    diagnostics.push(diagnostic("AI_SUITE_CONFIG_INVALID", message));
-    return { diagnostics };
-  }
+function mapStepStatus(s) {
+  if (s === void 0) return "running";
+  return s;
 }
-function normalizeSuiteConfig(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error("Suite config must export an object.");
-  }
-  const raw = value;
-  const name = asString(raw.name, "name");
-  const traces = asString(raw.traces, "traces");
-  if (name === void 0) throw new Error("name is required.");
-  if (traces === void 0) throw new Error("traces is required.");
-  if (!Array.isArray(raw.cases) || raw.cases.length === 0) {
-    throw new Error("cases must be a non-empty array.");
+function manualTraceEventsToComparableRun(events) {
+  const started = events.find((e) => e.event === "run_started");
+  if (!started || started.event !== "run_started") {
+    throw new Error("Invalid trace: missing run_started");
   }
-  const cases = [];
-  for (let index = 0; index < raw.cases.length; index += 1) {
-    const { caseConfig, diagnostics } = validateCaseConfig(raw.cases[index], index);
-    if (diagnostics.length > 0) {
-      throw new Error(diagnostics.map((item) => item.message).join("; "));
-    }
-    if (caseConfig !== void 0) cases.push(caseConfig);
+  const rs = started;
+  const runId = rs.runId;
+  const completedAll = events.filter((e) => e.event === "run_completed");
+  const lastCompleted = completedAll[completedAll.length - 1];
+  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 steps = /* @__PURE__ */ new Map();
+  let order = 0;
+  for (const e of events) {
+    if (e.event !== "step_started") continue;
+    const s = e;
+    const meta = s.metadata ? { ...s.metadata } : void 0;
+    steps.set(s.stepId, {
+      id: s.stepId,
+      parentId: s.parentId,
+      name: s.name,
+      type: s.type,
+      order: order++,
+      timestamp: s.timestamp,
+      metadata: meta
+    });
   }
-  const ids = /* @__PURE__ */ new Set();
-  for (const suiteCase of cases) {
-    if (ids.has(suiteCase.id)) {
-      throw new Error(`Duplicate case id "${suiteCase.id}".`);
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const acc = steps.get(e.stepId);
+    if (!acc) continue;
+    acc.status = e.status;
+    acc.durationMs = e.durationMs;
+    if (e.error?.message) acc.errorMsg = e.error.message;
+    const extra = e;
+    if (extra.metadata !== void 0 && typeof extra.metadata === "object") {
+      acc.metadata = { ...acc.metadata ?? {}, ...extra.metadata };
     }
-    ids.add(suiteCase.id);
   }
-  const redactionProfile = raw.redactionProfile === "local" || raw.redactionProfile === "share" || raw.redactionProfile === "strict" ? raw.redactionProfile : void 0;
-  if (raw.redactionProfile !== void 0 && redactionProfile === void 0) {
-    throw new Error('redactionProfile must be "local", "share", or "strict".');
-  }
-  const config = { name, traces, cases };
-  if (raw.checks !== void 0) {
-    if (typeof raw.checks !== "object" || Array.isArray(raw.checks)) {
-      throw new Error("checks must be an object.");
+  const nodes = /* @__PURE__ */ new Map();
+  for (const acc of steps.values()) {
+    let meta = acc.metadata ? { ...acc.metadata } : void 0;
+    if (acc.parentId !== void 0 && !steps.has(acc.parentId)) {
+      meta = { ...meta ?? {}, agent_inspect_diff_parent_missing: true };
     }
-    config.checks = raw.checks;
-  }
-  if (raw.eval !== void 0) {
-    if (typeof raw.eval !== "object" || Array.isArray(raw.eval)) {
-      throw new Error("eval must be an object.");
+    const outputPreview = extractOutputPreview(meta);
+    if (meta !== void 0 && ("outputPreview" in meta || "resultPreview" in meta)) {
+      delete meta.outputPreview;
+      delete meta.resultPreview;
     }
-    config.eval = raw.eval;
+    const sc = {
+      id: acc.id,
+      name: acc.name,
+      type: acc.type,
+      status: mapStepStatus(acc.status),
+      durationMs: acc.durationMs,
+      error: acc.errorMsg,
+      metadata: meta && Object.keys(meta).length > 0 ? meta : void 0,
+      outputPreview,
+      children: []
+    };
+    nodes.set(acc.id, sc);
   }
-  if (raw.artifacts !== void 0) {
-    if (typeof raw.artifacts !== "object" || Array.isArray(raw.artifacts)) {
-      throw new Error("artifacts must be an object.");
+  const roots = [];
+  const sortByOrder = (a, b) => {
+    const oa = steps.get(a.id)?.order ?? 0;
+    const ob = steps.get(b.id)?.order ?? 0;
+    return oa - ob;
+  };
+  for (const acc of steps.values()) {
+    const node = nodes.get(acc.id);
+    if (acc.parentId !== void 0 && nodes.has(acc.parentId)) {
+      nodes.get(acc.parentId).children.push(node);
+    } else {
+      roots.push(node);
     }
-    const outputDir = asString(
-      raw.artifacts.outputDir,
-      "artifacts.outputDir"
-    );
-    config.artifacts = outputDir !== void 0 ? { outputDir } : {};
-  }
-  if (raw.baseline !== void 0) {
-    const baseline = asString(raw.baseline, "baseline");
-    if (baseline !== void 0) config.baseline = baseline;
   }
-  if (raw.candidate !== void 0) {
-    const candidate = asString(raw.candidate, "candidate");
-    if (candidate !== void 0) config.candidate = candidate;
+  roots.sort(sortByOrder);
+  for (const n of nodes.values()) {
+    n.children.sort(sortByOrder);
   }
-  if (redactionProfile !== void 0) config.redactionProfile = redactionProfile;
-  return config;
+  return {
+    runId,
+    name: rs.name,
+    status: runStatus,
+    durationMs,
+    steps: roots
+  };
 }
 
-// packages/core/src/suite/load.ts
-var CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".js", ".mjs", ".cjs"]);
-var TS_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts"]);
-function diagnostic2(code, message) {
-  return { code, message, severity: "error" };
+// packages/core/src/diff/engine.ts
+var DEFAULT_THRESHOLD_MS = 0;
+function pathSeg(step, index) {
+  return { index, name: step.name, stepId: step.id };
 }
-async function fileExists(filePath) {
-  try {
-    await promises.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
+function buildPath(segments) {
+  return { path: [...segments] };
 }
-async function resolveSuiteConfigPath(options = {}) {
-  const cwd = path13__default.default.resolve(options.cwd ?? process.cwd());
-  if (options.configPath !== void 0 && options.configPath.trim() !== "") {
-    return path13__default.default.resolve(cwd, options.configPath.trim());
-  }
-  for (const name of DEFAULT_SUITE_CONFIG_NAMES) {
-    const candidate = path13__default.default.join(cwd, name);
-    if (await fileExists(candidate)) return candidate;
+function pairSteps(left, right) {
+  const usedRight = /* @__PURE__ */ new Set();
+  const pairs = [];
+  for (let i = 0; i < left.length; i++) {
+    const L = left[i];
+    let R = right.find((r) => !usedRight.has(r.id) && r.id === L.id);
+    if (R === void 0 && i < right.length && !usedRight.has(right[i].id)) {
+      const cand = right[i];
+      if (cand.name === L.name && (cand.type ?? "") === (L.type ?? "")) {
+        R = cand;
+      }
+    }
+    if (R === void 0) {
+      R = right.find(
+        (r) => !usedRight.has(r.id) && r.name === L.name && (r.type ?? "") === (L.type ?? "")
+      );
+    }
+    if (R !== void 0) {
+      usedRight.add(R.id);
+      pairs.push([L, R]);
+    } else {
+      pairs.push([L, void 0]);
+    }
   }
-  throw new Error(
-    `No suite config found. Create one with \`agent-inspect suite init\` or pass --config.`
-  );
+  for (const R of right) {
+    if (!usedRight.has(R.id)) {
+      pairs.push([void 0, R]);
+    }
+  }
+  return pairs;
 }
-async function loadSuiteConfig(options = {}) {
-  let configPath;
-  try {
-    configPath = await resolveSuiteConfigPath(options);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw Object.assign(new Error(message), {
-      diagnostics: [diagnostic2("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+function compareLeafSteps(L, R, segments, opts, out) {
+  const path18 = buildPath(segments);
+  if (L.name !== R.name) {
+    out.push({
+      kind: "structure",
+      severity: "warning",
+      message: "Step name differs",
+      path: path18,
+      left: L.name,
+      right: R.name
     });
   }
-  const extension = path13__default.default.extname(configPath);
-  if (TS_CONFIG_EXTENSIONS.has(extension)) {
-    const message = "TypeScript suite configs require an explicit precompiled JavaScript config or future --config-loader support.";
-    throw Object.assign(new Error(message), {
-      diagnostics: [diagnostic2("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+  if ((L.type ?? "") !== (R.type ?? "")) {
+    out.push({
+      kind: "step-type",
+      severity: "warning",
+      message: "Step type differs",
+      path: path18,
+      left: L.type,
+      right: R.type
     });
   }
-  if (!CONFIG_EXTENSIONS.has(extension)) {
-    const message = "Unsupported suite config extension. Use .json, .js, .mjs, or .cjs.";
-    throw Object.assign(new Error(message), {
-      diagnostics: [diagnostic2("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+  if ((L.status ?? "") !== (R.status ?? "")) {
+    out.push({
+      kind: "step-status",
+      severity: "warning",
+      message: "Step status differs",
+      path: path18,
+      left: L.status,
+      right: R.status
     });
   }
-  try {
-    let raw;
-    if (extension === ".json") {
-      raw = JSON.parse(await promises.readFile(configPath, "utf-8"));
-    } else {
-      const mod = await import(url.pathToFileURL(configPath).href);
-      raw = "default" in mod ? mod.default : mod;
-    }
-    const config = normalizeSuiteConfig(raw);
-    return {
-      config,
-      configPath,
-      configDir: path13__default.default.dirname(configPath)
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw Object.assign(new Error(message), {
-      diagnostics: [diagnostic2("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+  const le = L.error ?? "";
+  const re = R.error ?? "";
+  if (le !== re) {
+    out.push({
+      kind: "error",
+      severity: "error",
+      message: "Step error message differs",
+      path: path18,
+      left: le || void 0,
+      right: re || void 0
     });
   }
-}
-async function exists(filePath) {
-  try {
-    await promises.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function resolveSuiteCaseTrace(suiteCase, options) {
-  if (suiteCase.trace !== void 0) {
-    const tracePath = path13__default.default.resolve(options.configDir, suiteCase.trace);
-    if (await exists(tracePath)) {
-      return { caseId: suiteCase.id, tracePath, missing: false };
+  if (!opts.ignoreDuration) {
+    const ld = L.durationMs;
+    const rd = R.durationMs;
+    const th = opts.durationThresholdMs;
+    let differs = false;
+    if (ld === void 0 && rd === void 0) differs = false;
+    else if (ld === void 0 || rd === void 0) differs = true;
+    else differs = Math.abs(ld - rd) > th;
+    if (differs) {
+      out.push({
+        kind: "duration",
+        severity: "info",
+        message: "Step duration differs",
+        path: path18,
+        left: ld,
+        right: rd
+      });
     }
-    return {
-      caseId: suiteCase.id,
-      tracePath,
-      missing: true,
-      reason: `trace file not found: ${suiteCase.trace}`
-    };
   }
-  const runKey = suiteCase.runId ?? suiteCase.id;
-  const directPath = getTraceFilePath(runKey, options.tracesDir);
-  if (await exists(directPath)) {
-    return { caseId: suiteCase.id, tracePath: directPath, runId: runKey, missing: false };
+  const lm = stableJson(L.metadata ?? {});
+  const rm2 = stableJson(R.metadata ?? {});
+  if (lm !== rm2) {
+    out.push({
+      kind: "metadata",
+      severity: "info",
+      message: "Step metadata differs",
+      path: path18,
+      left: L.metadata,
+      right: R.metadata
+    });
   }
-  const nestedPath = path13__default.default.join(options.tracesDir, `${path13__default.default.basename(runKey)}.jsonl`);
-  if (await exists(nestedPath)) {
-    return { caseId: suiteCase.id, tracePath: nestedPath, runId: runKey, missing: false };
+  const lo = stableJson(L.outputPreview ?? null);
+  const ro = stableJson(R.outputPreview ?? null);
+  if (lo !== ro) {
+    out.push({
+      kind: "output",
+      severity: "info",
+      message: "Output preview differs",
+      path: path18,
+      left: L.outputPreview,
+      right: R.outputPreview
+    });
   }
-  return {
-    caseId: suiteCase.id,
-    runId: runKey,
-    missing: true,
-    reason: `no trace found for run id "${runKey}" under ${options.tracesDir}`
-  };
 }
-
-// packages/core/src/checks/index.ts
-var SEVERITY_RANK = {
-  error: 0,
-  warning: 1,
-  info: 2
-};
-var STATUS_RANK = {
-  fail: 0,
-  warning: 1,
-  pass: 2
-};
-function compareStrings(a, b) {
-  return (a ?? "").localeCompare(b ?? "");
+function compareRecursive(L, R, segments, opts, out) {
+  compareLeafSteps(L, R, segments, opts, out);
+  const pairs = pairSteps(L.children, R.children);
+  let ci = 0;
+  for (const [lch, rch] of pairs) {
+    if (lch !== void 0 && rch !== void 0) {
+      compareRecursive(lch, rch, [...segments, pathSeg(lch, ci)], opts, out);
+    } else if (lch !== void 0) {
+      out.push({
+        kind: "step-removed",
+        severity: "warning",
+        message: `Step only in left run: ${lch.name}`,
+        path: buildPath([...segments, pathSeg(lch, ci)]),
+        left: lch.id,
+        right: void 0
+      });
+    } else if (rch !== void 0) {
+      out.push({
+        kind: "step-added",
+        severity: "warning",
+        message: `Step only in right run: ${rch.name}`,
+        path: buildPath([...segments, pathSeg(rch, ci)]),
+        left: void 0,
+        right: rch.id
+      });
+    }
+    ci += 1;
+  }
 }
-function diagnostic3(code, message, ruleId) {
+function mergeDiffDefaults(options) {
   return {
-    code,
-    message,
-    severity: "error",
-    ...ruleId ? { ruleId } : {}
+    ignoreDuration: false,
+    durationThresholdMs: DEFAULT_THRESHOLD_MS,
+    focus: "all",
+    check: "all"
   };
 }
-function emptySummary() {
-  return {
-    passed: 0,
-    failed: 0,
-    warnings: 0,
-    errors: 0
-  };
+function kindMatchesFilter(kind, merged) {
+  return true;
 }
-function errorResult(input, diagnostics, selectedRun) {
-  return {
-    ok: false,
-    status: "error",
-    format: input.read.format,
-    ...selectedRun ? { runId: selectedRun.runId } : {},
-    summary: {
-      ...emptySummary(),
-      errors: diagnostics.filter((item) => item.severity === "error").length
-    },
-    findings: [],
-    diagnostics: [...diagnostics]
+function diffRuns(left, right, options) {
+  const merged = mergeDiffDefaults();
+  const opts = {
+    ignoreDuration: merged.ignoreDuration,
+    durationThresholdMs: merged.durationThresholdMs
   };
-}
-function flattenNodes(nodes) {
-  return nodes.flatMap((node) => [node, ...flattenNodes(node.children)]);
-}
-function buildFacts(input, selectedRun) {
-  const scopedRuns = selectedRun ? [selectedRun] : input.read.runs;
-  const scopedRunIds = new Set(scopedRuns.map((run) => run.runId));
-  const scopedEvents = selectedRun === void 0 ? input.read.events : input.read.events.filter((event) => scopedRunIds.has(event.runId));
-  const nodes = flattenNodes(scopedRuns.flatMap((run) => run.children));
-  const nodesByEventId = /* @__PURE__ */ new Map();
-  const childrenByParentId = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    nodesByEventId.set(node.event.eventId, node);
-    const parentId = node.event.parentId;
-    if (parentId) {
-      const children = childrenByParentId.get(parentId) ?? [];
-      children.push(node);
-      childrenByParentId.set(parentId, children);
-    }
+  const raw = [];
+  if ((left.status ?? "") !== (right.status ?? "")) {
+    raw.push({
+      kind: "run-status",
+      severity: "warning",
+      message: "Run completion status differs",
+      left: left.status,
+      right: right.status
+    });
   }
-  return {
-    format: input.read.format,
-    runs: Object.freeze([...input.read.runs]),
-    events: Object.freeze([...scopedEvents]),
-    readerWarnings: Object.freeze([...input.read.warnings]),
-    unsupportedFields: Object.freeze([...input.read.unsupportedFields]),
-    sourceFiles: Object.freeze([...input.read.sourceFiles]),
-    nodesByEventId,
-    childrenByParentId,
-    rootNodes: Object.freeze(scopedRuns.flatMap((run) => run.children))
-  };
-}
-function resolveSelectedRun(input, runId) {
-  if (input.selectedRun) {
-    if (runId && input.selectedRun.runId !== runId) {
-      return {
-        diagnostics: [
-          diagnostic3(
-            "AI_CHECK_INVALID_ARGUMENTS",
-            `Selected run ${input.selectedRun.runId} does not match requested run ${runId}.`
-          )
-        ]
-      };
+  {
+    const ld = left.durationMs;
+    const rd = right.durationMs;
+    const th = merged.durationThresholdMs;
+    let differs = false;
+    if (ld === void 0 && rd === void 0) differs = false;
+    else if (ld === void 0 || rd === void 0) differs = true;
+    else differs = Math.abs(ld - rd) > th;
+    if (differs) {
+      raw.push({
+        kind: "duration",
+        severity: "info",
+        message: "Run duration differs",
+        left: ld,
+        right: rd
+      });
     }
-    return { run: input.selectedRun, diagnostics: [] };
   }
-  if (runId) {
-    const run = input.read.runs.find((candidate) => candidate.runId === runId);
-    if (!run) {
-      return {
-        diagnostics: [
-          diagnostic3("AI_CHECK_RUN_SELECTION_REQUIRED", `Run not found: ${runId}.`)
-        ]
-      };
+  const pairs = pairSteps(left.steps, right.steps);
+  let idx = 0;
+  for (const [ls, rs] of pairs) {
+    if (ls !== void 0 && rs !== void 0) {
+      compareRecursive(ls, rs, [pathSeg(ls, idx)], opts, raw);
+      idx += 1;
+    } else if (ls !== void 0) {
+      raw.push({
+        kind: "step-removed",
+        severity: "warning",
+        message: `Step only in left run: ${ls.name}`,
+        path: buildPath([pathSeg(ls, idx)]),
+        left: ls.id,
+        right: void 0
+      });
+      idx += 1;
+    } else if (rs !== void 0) {
+      raw.push({
+        kind: "step-added",
+        severity: "warning",
+        message: `Step only in right run: ${rs.name}`,
+        path: buildPath([pathSeg(rs, idx)]),
+        left: void 0,
+        right: rs.id
+      });
+      idx += 1;
     }
-    return { run, diagnostics: [] };
-  }
-  if (input.read.runs.length === 1) {
-    return { run: input.read.runs[0], diagnostics: [] };
   }
-  if (input.read.runs.length === 0) {
-    return {
-      diagnostics: [
-        diagnostic3("AI_CHECK_RUN_SELECTION_REQUIRED", "No runs are available for checks.")
-      ]
-    };
+  const differences = raw.filter((d) => kindMatchesFilter(d.kind));
+  let errors = 0;
+  let warnings = 0;
+  let info = 0;
+  for (const d of differences) {
+    if (d.severity === "error") errors += 1;
+    else if (d.severity === "warning") warnings += 1;
+    else info += 1;
   }
-  return {
-    diagnostics: [
-      diagnostic3(
-        "AI_CHECK_RUN_SELECTION_REQUIRED",
-        "Multiple runs are available; select a run before executing checks."
-      )
-    ]
+  const firstVisible = differences[0];
+  const firstDivergence = firstVisible !== void 0 ? {
+    kind: "first-divergence",
+    severity: firstVisible.severity,
+    message: `First divergence: ${firstVisible.message}`,
+    path: firstVisible.path,
+    left: firstVisible.left,
+    right: firstVisible.right
+  } : void 0;
+  const summary = {
+    leftRunId: left.runId,
+    rightRunId: right.runId,
+    totalDifferences: differences.length,
+    errors,
+    warnings,
+    info,
+    firstDivergence
   };
+  return { summary, differences };
 }
-function selectRules(rules, selectedIds) {
+
+// packages/core/src/evidence/zip.ts
+(() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n += 1) {
+    let c = n;
+    for (let k = 0; k < 8; k += 1) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+
+// packages/core/src/suite/types.ts
+var DEFAULT_SUITE_CONFIG_NAMES = [
+  "agent-inspect.suite.json",
+  "agent-inspect.suite.js",
+  "agent-inspect.suite.mjs",
+  "agent-inspect.suite.cjs"
+];
+function diagnostic(code, message, severity = "error", caseId) {
+  return { code, message, severity, ...{} };
+}
+function asString(value, label) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  return value.trim();
+}
+function asStringArray(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 asPositiveNumber(value, label) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative number.`);
+  }
+  return value;
+}
+function validateCaseConfig(value, index) {
   const diagnostics = [];
-  const byId = /* @__PURE__ */ new Map();
-  for (const rule of rules) {
-    if (byId.has(rule.id)) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    diagnostics.push(
+      diagnostic("AI_SUITE_CONFIG_INVALID", `cases[${index}] must be an object.`)
+    );
+    return { diagnostics };
+  }
+  const raw = value;
+  try {
+    const id = asString(raw.id, `cases[${index}].id`);
+    if (id === void 0) {
       diagnostics.push(
-        diagnostic3("AI_CHECK_INVALID_CONFIG", `Duplicate trace check rule id: ${rule.id}.`, rule.id)
+        diagnostic("AI_SUITE_CONFIG_INVALID", `cases[${index}].id is required.`)
       );
-      continue;
-    }
-    byId.set(rule.id, rule);
-  }
-  if (selectedIds && selectedIds.length > 0) {
-    const selected = new Set(selectedIds);
-    for (const id of selected) {
-      if (!byId.has(id)) {
-        diagnostics.push(
-          diagnostic3("AI_CHECK_INVALID_CONFIG", `Unknown trace check rule id: ${id}.`, id)
-        );
-      }
+      return { diagnostics };
     }
+    const trace = asString(raw.trace, `cases[${index}].trace`);
+    const runId = asString(raw.runId, `cases[${index}].runId`);
+    const input = asString(raw.input, `cases[${index}].input`);
     return {
-      rules: [...byId.values()].filter((rule) => selected.has(rule.id)).sort(compareRules),
+      caseConfig: {
+        id,
+        ...trace !== void 0 ? { trace } : {},
+        ...runId !== void 0 ? { runId } : {},
+        ...input !== void 0 ? { input } : {},
+        ...asStringArray(raw.requireTools, `cases[${index}].requireTools`) !== void 0 ? { requireTools: asStringArray(raw.requireTools, `cases[${index}].requireTools`) } : {},
+        ...asStringArray(raw.forbidTools, `cases[${index}].forbidTools`) !== void 0 ? { forbidTools: asStringArray(raw.forbidTools, `cases[${index}].forbidTools`) } : {},
+        ...asPositiveNumber(raw.maxDurationMs, `cases[${index}].maxDurationMs`) !== void 0 ? {
+          maxDurationMs: asPositiveNumber(
+            raw.maxDurationMs,
+            `cases[${index}].maxDurationMs`
+          )
+        } : {},
+        ...asStringArray(
+          raw.expectedObservations,
+          `cases[${index}].expectedObservations`
+        ) !== void 0 ? {
+          expectedObservations: asStringArray(
+            raw.expectedObservations,
+            `cases[${index}].expectedObservations`
+          )
+        } : {}
+      },
       diagnostics
     };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    diagnostics.push(diagnostic("AI_SUITE_CONFIG_INVALID", message));
+    return { diagnostics };
   }
-  return { rules: [...byId.values()].sort(compareRules), diagnostics };
-}
-function compareRules(a, b) {
-  return a.id.localeCompare(b.id);
-}
-function eventTimestamp(finding, eventById) {
-  const eventId = finding.evidence[0]?.eventId;
-  return eventId ? eventById.get(eventId)?.timestamp ?? "" : "";
 }
-function compareFindings(eventById) {
-  return (a, b) => {
-    if (SEVERITY_RANK[a.severity] !== SEVERITY_RANK[b.severity]) {
-      return SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity];
+function normalizeSuiteConfig(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("Suite config must export an object.");
+  }
+  const raw = value;
+  const name = asString(raw.name, "name");
+  const traces = asString(raw.traces, "traces");
+  if (name === void 0) throw new Error("name is required.");
+  if (traces === void 0) throw new Error("traces is required.");
+  if (!Array.isArray(raw.cases) || raw.cases.length === 0) {
+    throw new Error("cases must be a non-empty array.");
+  }
+  const cases = [];
+  for (let index = 0; index < raw.cases.length; index += 1) {
+    const { caseConfig, diagnostics } = validateCaseConfig(raw.cases[index], index);
+    if (diagnostics.length > 0) {
+      throw new Error(diagnostics.map((item) => item.message).join("; "));
     }
-    const byRule = a.ruleId.localeCompare(b.ruleId);
-    if (byRule !== 0) return byRule;
-    if (STATUS_RANK[a.status] !== STATUS_RANK[b.status]) {
-      return STATUS_RANK[a.status] - STATUS_RANK[b.status];
+    if (caseConfig !== void 0) cases.push(caseConfig);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const suiteCase of cases) {
+    if (ids.has(suiteCase.id)) {
+      throw new Error(`Duplicate case id "${suiteCase.id}".`);
     }
-    const byRun = compareStrings(a.evidence[0]?.runId, b.evidence[0]?.runId);
-    if (byRun !== 0) return byRun;
-    const byTime = eventTimestamp(a, eventById).localeCompare(eventTimestamp(b, eventById));
-    if (byTime !== 0) return byTime;
-    const byEvent = compareStrings(a.evidence[0]?.eventId, b.evidence[0]?.eventId);
-    if (byEvent !== 0) return byEvent;
-    return compareStrings(a.evidence[0]?.path, b.evidence[0]?.path);
-  };
+    ids.add(suiteCase.id);
+  }
+  const redactionProfile = raw.redactionProfile === "local" || raw.redactionProfile === "share" || raw.redactionProfile === "strict" ? raw.redactionProfile : void 0;
+  if (raw.redactionProfile !== void 0 && redactionProfile === void 0) {
+    throw new Error('redactionProfile must be "local", "share", or "strict".');
+  }
+  const config = { name, traces, cases };
+  if (raw.checks !== void 0) {
+    if (typeof raw.checks !== "object" || Array.isArray(raw.checks)) {
+      throw new Error("checks must be an object.");
+    }
+    config.checks = raw.checks;
+  }
+  if (raw.eval !== void 0) {
+    if (typeof raw.eval !== "object" || Array.isArray(raw.eval)) {
+      throw new Error("eval must be an object.");
+    }
+    config.eval = raw.eval;
+  }
+  if (raw.artifacts !== void 0) {
+    if (typeof raw.artifacts !== "object" || Array.isArray(raw.artifacts)) {
+      throw new Error("artifacts must be an object.");
+    }
+    const outputDir = asString(
+      raw.artifacts.outputDir,
+      "artifacts.outputDir"
+    );
+    config.artifacts = outputDir !== void 0 ? { outputDir } : {};
+  }
+  if (raw.baseline !== void 0) {
+    const baseline = asString(raw.baseline, "baseline");
+    if (baseline !== void 0) config.baseline = baseline;
+  }
+  if (raw.candidate !== void 0) {
+    const candidate = asString(raw.candidate, "candidate");
+    if (candidate !== void 0) config.candidate = candidate;
+  }
+  if (redactionProfile !== void 0) config.redactionProfile = redactionProfile;
+  return config;
 }
-function normalizeFinding(rule, finding) {
-  return {
-    ruleId: finding.ruleId || rule.id,
-    severity: finding.severity ?? rule.defaultSeverity,
-    status: finding.status,
-    message: finding.message,
-    ...finding.expected !== void 0 ? { expected: finding.expected } : {},
-    ...finding.actual !== void 0 ? { actual: finding.actual } : {},
-    evidence: [...finding.evidence ?? []],
-    ...finding.category !== void 0 ? { category: finding.category } : {},
-    ...finding.confidence !== void 0 ? { confidence: finding.confidence } : {},
-    ...finding.detector !== void 0 ? { detector: finding.detector } : {},
-    ...finding.action !== void 0 ? { action: finding.action } : {}
-  };
+
+// packages/core/src/suite/load.ts
+var CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".js", ".mjs", ".cjs"]);
+var TS_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts"]);
+function diagnostic2(code, message) {
+  return { code, message, severity: "error" };
 }
-function summarize(findings, diagnostics) {
-  return {
-    passed: findings.filter((finding) => finding.status === "pass").length,
-    failed: findings.filter(
-      (finding) => finding.status === "fail" && finding.severity === "error"
-    ).length,
-    warnings: findings.filter(
-      (finding) => finding.status === "warning" || finding.severity === "warning"
-    ).length,
-    errors: diagnostics.filter((item) => item.severity === "error").length
-  };
+async function fileExists(filePath) {
+  try {
+    await promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function stringAttr(event, keys) {
-  for (const key of keys) {
-    const value = event.attributes?.[key];
-    if (typeof value === "string" && value.trim() !== "") return value;
+async function resolveSuiteConfigPath(options = {}) {
+  const cwd = path15__default.default.resolve(options.cwd ?? process.cwd());
+  if (options.configPath !== void 0 && options.configPath.trim() !== "") {
+    return path15__default.default.resolve(cwd, options.configPath.trim());
   }
-  return void 0;
+  for (const name of DEFAULT_SUITE_CONFIG_NAMES) {
+    const candidate = path15__default.default.join(cwd, name);
+    if (await fileExists(candidate)) return candidate;
+  }
+  throw new Error(
+    `No suite config found. Create one with \`agent-inspect suite init\` or pass --config.`
+  );
 }
-function stripPrefix(name, prefixes) {
-  for (const prefix of prefixes) {
-    if (name.startsWith(prefix)) return name.slice(prefix.length);
+async function loadSuiteConfig(options = {}) {
+  let configPath;
+  try {
+    configPath = await resolveSuiteConfigPath(options);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw Object.assign(new Error(message), {
+      diagnostics: [diagnostic2("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+    });
+  }
+  const extension = path15__default.default.extname(configPath);
+  if (TS_CONFIG_EXTENSIONS.has(extension)) {
+    const message = "TypeScript suite configs require an explicit precompiled JavaScript config or future --config-loader support.";
+    throw Object.assign(new Error(message), {
+      diagnostics: [diagnostic2("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+    });
+  }
+  if (!CONFIG_EXTENSIONS.has(extension)) {
+    const message = "Unsupported suite config extension. Use .json, .js, .mjs, or .cjs.";
+    throw Object.assign(new Error(message), {
+      diagnostics: [diagnostic2("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+    });
+  }
+  try {
+    let raw;
+    if (extension === ".json") {
+      raw = JSON.parse(await promises.readFile(configPath, "utf-8"));
+    } else {
+      const mod = await import(url.pathToFileURL(configPath).href);
+      raw = "default" in mod ? mod.default : mod;
+    }
+    const config = normalizeSuiteConfig(raw);
+    return {
+      config,
+      configPath,
+      configDir: path15__default.default.dirname(configPath)
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw Object.assign(new Error(message), {
+      diagnostics: [diagnostic2("AI_SUITE_CONFIG_LOAD_FAILED", message)]
+    });
+  }
+}
+async function exists(filePath) {
+  try {
+    await promises.access(filePath);
+    return true;
+  } catch {
+    return false;
   }
-  return name;
 }
-function eventEvidence(event, path16) {
+async function resolveSuiteCaseTrace(suiteCase, options) {
+  if (suiteCase.trace !== void 0) {
+    const tracePath = path15__default.default.resolve(options.configDir, suiteCase.trace);
+    if (await exists(tracePath)) {
+      return { caseId: suiteCase.id, tracePath, missing: false };
+    }
+    return {
+      caseId: suiteCase.id,
+      tracePath,
+      missing: true,
+      reason: `trace file not found: ${suiteCase.trace}`
+    };
+  }
+  const runKey = suiteCase.runId ?? suiteCase.id;
+  const directPath = getTraceFilePath(runKey, options.tracesDir);
+  if (await exists(directPath)) {
+    return { caseId: suiteCase.id, tracePath: directPath, runId: runKey, missing: false };
+  }
+  const nestedPath = path15__default.default.join(options.tracesDir, `${path15__default.default.basename(runKey)}.jsonl`);
+  if (await exists(nestedPath)) {
+    return { caseId: suiteCase.id, tracePath: nestedPath, runId: runKey, missing: false };
+  }
   return {
-    runId: event.runId,
-    eventId: event.eventId,
-    parentId: event.parentId,
-    traceId: event.trace?.traceId,
-    spanId: event.trace?.spanId,
-    kind: event.kind,
-    name: event.name,
-    status: event.status,
-    ...path16 ? { path: path16 } : {}
+    caseId: suiteCase.id,
+    runId: runKey,
+    missing: true,
+    reason: `no trace found for run id "${runKey}" under ${options.tracesDir}`
   };
 }
-function runEvidence(run) {
-  return run ? [{ runId: run.runId, name: run.name, status: run.status }] : [];
+
+// packages/core/src/checks/index.ts
+var SEVERITY_RANK = {
+  error: 0,
+  warning: 1,
+  info: 2
+};
+var STATUS_RANK = {
+  fail: 0,
+  warning: 1,
+  pass: 2
+};
+function compareStrings(a, b) {
+  return (a ?? "").localeCompare(b ?? "");
 }
-function failFinding(ruleId, message, evidence, expected, actual, meta) {
+function diagnostic3(code, message, ruleId) {
   return {
-    ruleId,
-    severity: meta?.severity ?? "error",
-    status: meta?.status ?? "fail",
+    code,
     message,
-    ...expected !== void 0 ? { expected } : {},
-    ...actual !== void 0 ? { actual } : {},
-    evidence: [...evidence],
-    ...{},
-    ...{},
-    ...{},
-    ...{}
+    severity: "error",
+    ...ruleId ? { ruleId } : {}
   };
 }
-function toolName(event) {
-  return stringAttr(event, ["toolName", "tool"]) ?? stripPrefix(event.name, ["tool:", "function:", "mcp-tools:"]);
-}
-function llmModel(event) {
-  return stringAttr(event, ["model", "modelId", "responseModelId", "modelName", "model_name"]) ?? stripPrefix(event.name, ["llm:", "generation:", "transcription:", "speech:"]);
+function emptySummary() {
+  return {
+    passed: 0,
+    failed: 0,
+    warnings: 0,
+    errors: 0
+  };
 }
-function llmProvider(event) {
-  return stringAttr(event, ["provider", "providerName", "provider_name"]);
+function errorResult(input, diagnostics, selectedRun) {
+  return {
+    ok: false,
+    status: "error",
+    format: input.read.format,
+    ...selectedRun ? { runId: selectedRun.runId } : {},
+    summary: {
+      ...emptySummary(),
+      errors: diagnostics.filter((item) => item.severity === "error").length
+    },
+    findings: [],
+    diagnostics: [...diagnostics]
+  };
 }
-function llmFinishReason(event) {
-  return stringAttr(event, ["finishReason", "rawFinishReason", "finish_reason"]);
+function flattenNodes(nodes) {
+  return nodes.flatMap((node) => [node, ...flattenNodes(node.children)]);
 }
-function finishedEvents(context, kind) {
-  return context.events.filter(
-    (event) => (kind === void 0 || event.kind === kind) && event.status !== "running"
-  );
+function buildFacts(input, selectedRun) {
+  const scopedRuns = selectedRun ? [selectedRun] : input.read.runs;
+  const scopedRunIds = new Set(scopedRuns.map((run) => run.runId));
+  const scopedEvents = selectedRun === void 0 ? input.read.events : input.read.events.filter((event) => scopedRunIds.has(event.runId));
+  const nodes = flattenNodes(scopedRuns.flatMap((run) => run.children));
+  const nodesByEventId = /* @__PURE__ */ new Map();
+  const childrenByParentId = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodesByEventId.set(node.event.eventId, node);
+    const parentId = node.event.parentId;
+    if (parentId) {
+      const children = childrenByParentId.get(parentId) ?? [];
+      children.push(node);
+      childrenByParentId.set(parentId, children);
+    }
+  }
+  return {
+    format: input.read.format,
+    runs: Object.freeze([...input.read.runs]),
+    events: Object.freeze([...scopedEvents]),
+    readerWarnings: Object.freeze([...input.read.warnings]),
+    unsupportedFields: Object.freeze([...input.read.unsupportedFields]),
+    sourceFiles: Object.freeze([...input.read.sourceFiles]),
+    nodesByEventId,
+    childrenByParentId,
+    rootNodes: Object.freeze(scopedRuns.flatMap((run) => run.children))
+  };
+}
+function resolveSelectedRun(input, runId) {
+  if (input.selectedRun) {
+    if (runId && input.selectedRun.runId !== runId) {
+      return {
+        diagnostics: [
+          diagnostic3(
+            "AI_CHECK_INVALID_ARGUMENTS",
+            `Selected run ${input.selectedRun.runId} does not match requested run ${runId}.`
+          )
+        ]
+      };
+    }
+    return { run: input.selectedRun, diagnostics: [] };
+  }
+  if (runId) {
+    const run = input.read.runs.find((candidate) => candidate.runId === runId);
+    if (!run) {
+      return {
+        diagnostics: [
+          diagnostic3("AI_CHECK_RUN_SELECTION_REQUIRED", `Run not found: ${runId}.`)
+        ]
+      };
+    }
+    return { run, diagnostics: [] };
+  }
+  if (input.read.runs.length === 1) {
+    return { run: input.read.runs[0], diagnostics: [] };
+  }
+  if (input.read.runs.length === 0) {
+    return {
+      diagnostics: [
+        diagnostic3("AI_CHECK_RUN_SELECTION_REQUIRED", "No runs are available for checks.")
+      ]
+    };
+  }
+  return {
+    diagnostics: [
+      diagnostic3(
+        "AI_CHECK_RUN_SELECTION_REQUIRED",
+        "Multiple runs are available; select a run before executing checks."
+      )
+    ]
+  };
+}
+function selectRules(rules, selectedIds) {
+  const diagnostics = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (byId.has(rule.id)) {
+      diagnostics.push(
+        diagnostic3("AI_CHECK_INVALID_CONFIG", `Duplicate trace check rule id: ${rule.id}.`, rule.id)
+      );
+      continue;
+    }
+    byId.set(rule.id, rule);
+  }
+  if (selectedIds && selectedIds.length > 0) {
+    const selected = new Set(selectedIds);
+    for (const id of selected) {
+      if (!byId.has(id)) {
+        diagnostics.push(
+          diagnostic3("AI_CHECK_INVALID_CONFIG", `Unknown trace check rule id: ${id}.`, id)
+        );
+      }
+    }
+    return {
+      rules: [...byId.values()].filter((rule) => selected.has(rule.id)).sort(compareRules),
+      diagnostics
+    };
+  }
+  return { rules: [...byId.values()].sort(compareRules), diagnostics };
+}
+function compareRules(a, b) {
+  return a.id.localeCompare(b.id);
+}
+function eventTimestamp(finding, eventById) {
+  const eventId = finding.evidence[0]?.eventId;
+  return eventId ? eventById.get(eventId)?.timestamp ?? "" : "";
+}
+function compareFindings(eventById) {
+  return (a, b) => {
+    if (SEVERITY_RANK[a.severity] !== SEVERITY_RANK[b.severity]) {
+      return SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity];
+    }
+    const byRule = a.ruleId.localeCompare(b.ruleId);
+    if (byRule !== 0) return byRule;
+    if (STATUS_RANK[a.status] !== STATUS_RANK[b.status]) {
+      return STATUS_RANK[a.status] - STATUS_RANK[b.status];
+    }
+    const byRun = compareStrings(a.evidence[0]?.runId, b.evidence[0]?.runId);
+    if (byRun !== 0) return byRun;
+    const byTime = eventTimestamp(a, eventById).localeCompare(eventTimestamp(b, eventById));
+    if (byTime !== 0) return byTime;
+    const byEvent = compareStrings(a.evidence[0]?.eventId, b.evidence[0]?.eventId);
+    if (byEvent !== 0) return byEvent;
+    return compareStrings(a.evidence[0]?.path, b.evidence[0]?.path);
+  };
+}
+function normalizeFinding(rule, finding) {
+  return {
+    ruleId: finding.ruleId || rule.id,
+    severity: finding.severity ?? rule.defaultSeverity,
+    status: finding.status,
+    message: finding.message,
+    ...finding.expected !== void 0 ? { expected: finding.expected } : {},
+    ...finding.actual !== void 0 ? { actual: finding.actual } : {},
+    evidence: [...finding.evidence ?? []],
+    ...finding.category !== void 0 ? { category: finding.category } : {},
+    ...finding.confidence !== void 0 ? { confidence: finding.confidence } : {},
+    ...finding.detector !== void 0 ? { detector: finding.detector } : {},
+    ...finding.action !== void 0 ? { action: finding.action } : {}
+  };
+}
+function summarize(findings, diagnostics) {
+  return {
+    passed: findings.filter((finding) => finding.status === "pass").length,
+    failed: findings.filter(
+      (finding) => finding.status === "fail" && finding.severity === "error"
+    ).length,
+    warnings: findings.filter(
+      (finding) => finding.status === "warning" || finding.severity === "warning"
+    ).length,
+    errors: diagnostics.filter((item) => item.severity === "error").length
+  };
+}
+function stringAttr(event, keys) {
+  for (const key of keys) {
+    const value = event.attributes?.[key];
+    if (typeof value === "string" && value.trim() !== "") return value;
+  }
+  return void 0;
+}
+function stripPrefix(name, prefixes) {
+  for (const prefix of prefixes) {
+    if (name.startsWith(prefix)) return name.slice(prefix.length);
+  }
+  return name;
+}
+function eventEvidence(event, path18) {
+  return {
+    runId: event.runId,
+    eventId: event.eventId,
+    parentId: event.parentId,
+    traceId: event.trace?.traceId,
+    spanId: event.trace?.spanId,
+    kind: event.kind,
+    name: event.name,
+    status: event.status,
+    ...path18 ? { path: path18 } : {}
+  };
+}
+function runEvidence(run) {
+  return run ? [{ runId: run.runId, name: run.name, status: run.status }] : [];
+}
+function failFinding(ruleId, message, evidence, expected, actual, meta) {
+  return {
+    ruleId,
+    severity: meta?.severity ?? "error",
+    status: meta?.status ?? "fail",
+    message,
+    ...expected !== void 0 ? { expected } : {},
+    ...actual !== void 0 ? { actual } : {},
+    evidence: [...evidence],
+    ...{},
+    ...{},
+    ...{},
+    ...{}
+  };
+}
+function toolName(event) {
+  return stringAttr(event, ["toolName", "tool"]) ?? stripPrefix(event.name, ["tool:", "function:", "mcp-tools:"]);
+}
+function llmModel(event) {
+  return stringAttr(event, ["model", "modelId", "responseModelId", "modelName", "model_name"]) ?? stripPrefix(event.name, ["llm:", "generation:", "transcription:", "speech:"]);
+}
+function llmProvider(event) {
+  return stringAttr(event, ["provider", "providerName", "provider_name"]);
+}
+function llmFinishReason(event) {
+  return stringAttr(event, ["finishReason", "rawFinishReason", "finish_reason"]);
+}
+function finishedEvents(context, kind) {
+  return context.events.filter(
+    (event) => (kind === void 0 || event.kind === kind) && event.status !== "running"
+  );
 }
 function createRunStatusRule(options = {}) {
   const expected = options.expected ?? "ok";
@@ -2979,7 +3370,7 @@ function findReaderByFormat(format, readers) {
 }
 async function jsonlFilesInDirectory(dirPath) {
   const entries = await promises.readdir(dirPath, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path13__default.default.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path15__default.default.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
 }
 async function resolveInput(input) {
   const cached = resolvedInputCache.get(input);
@@ -4599,7 +4990,7 @@ async function runSuiteCase(suiteCase, config, options) {
 async function runSuite(options = {}) {
   const startedAt = new Date(options.nowMs ?? Date.now()).toISOString();
   const { config, configPath, configDir } = await loadSuiteConfig(options);
-  const tracesDir = path13__default.default.resolve(configDir, config.traces);
+  const tracesDir = path15__default.default.resolve(configDir, config.traces);
   const cases = [];
   const diagnostics = [];
   for (const suiteCase of config.cases) {
@@ -4634,22 +5025,6 @@ async function runSuite(options = {}) {
   };
 }
 
-// packages/core/src/exporters/helpers.ts
-function sortKeysDeep(input) {
-  if (input === null || typeof input !== "object") return input;
-  if (Array.isArray(input)) return input.map(sortKeysDeep);
-  const o = input;
-  const out = {};
-  for (const k of Object.keys(o).sort()) {
-    out[k] = sortKeysDeep(o[k]);
-  }
-  return out;
-}
-function stableJson(value, pretty) {
-  const sorted = sortKeysDeep(value);
-  return JSON.stringify(sorted);
-}
-
 // packages/viewer/src/html.ts
 var viewerIndexHtml = `<!DOCTYPE html>
 <html lang="en">
@@ -4739,370 +5114,6 @@ var viewerIndexHtml = `<!DOCTYPE html>
 </body>
 </html>
 `;
-
-// packages/core/src/diff/comparable.ts
-function extractOutputPreview(meta) {
-  if (meta === void 0) return void 0;
-  if ("outputPreview" in meta) return meta.outputPreview;
-  if ("resultPreview" in meta) return meta.resultPreview;
-  return void 0;
-}
-function mapStepStatus(s) {
-  if (s === void 0) return "running";
-  return s;
-}
-function manualTraceEventsToComparableRun(events) {
-  const started = events.find((e) => e.event === "run_started");
-  if (!started || started.event !== "run_started") {
-    throw new Error("Invalid trace: missing run_started");
-  }
-  const rs = started;
-  const runId = rs.runId;
-  const completedAll = events.filter((e) => e.event === "run_completed");
-  const lastCompleted = completedAll[completedAll.length - 1];
-  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 steps = /* @__PURE__ */ new Map();
-  let order = 0;
-  for (const e of events) {
-    if (e.event !== "step_started") continue;
-    const s = e;
-    const meta = s.metadata ? { ...s.metadata } : void 0;
-    steps.set(s.stepId, {
-      id: s.stepId,
-      parentId: s.parentId,
-      name: s.name,
-      type: s.type,
-      order: order++,
-      timestamp: s.timestamp,
-      metadata: meta
-    });
-  }
-  for (const e of events) {
-    if (e.event !== "step_completed") continue;
-    const acc = steps.get(e.stepId);
-    if (!acc) continue;
-    acc.status = e.status;
-    acc.durationMs = e.durationMs;
-    if (e.error?.message) acc.errorMsg = e.error.message;
-    const extra = e;
-    if (extra.metadata !== void 0 && typeof extra.metadata === "object") {
-      acc.metadata = { ...acc.metadata ?? {}, ...extra.metadata };
-    }
-  }
-  const nodes = /* @__PURE__ */ new Map();
-  for (const acc of steps.values()) {
-    let meta = acc.metadata ? { ...acc.metadata } : void 0;
-    if (acc.parentId !== void 0 && !steps.has(acc.parentId)) {
-      meta = { ...meta ?? {}, agent_inspect_diff_parent_missing: true };
-    }
-    const outputPreview = extractOutputPreview(meta);
-    if (meta !== void 0 && ("outputPreview" in meta || "resultPreview" in meta)) {
-      delete meta.outputPreview;
-      delete meta.resultPreview;
-    }
-    const sc = {
-      id: acc.id,
-      name: acc.name,
-      type: acc.type,
-      status: mapStepStatus(acc.status),
-      durationMs: acc.durationMs,
-      error: acc.errorMsg,
-      metadata: meta && Object.keys(meta).length > 0 ? meta : void 0,
-      outputPreview,
-      children: []
-    };
-    nodes.set(acc.id, sc);
-  }
-  const roots = [];
-  const sortByOrder = (a, b) => {
-    const oa = steps.get(a.id)?.order ?? 0;
-    const ob = steps.get(b.id)?.order ?? 0;
-    return oa - ob;
-  };
-  for (const acc of steps.values()) {
-    const node = nodes.get(acc.id);
-    if (acc.parentId !== void 0 && nodes.has(acc.parentId)) {
-      nodes.get(acc.parentId).children.push(node);
-    } else {
-      roots.push(node);
-    }
-  }
-  roots.sort(sortByOrder);
-  for (const n of nodes.values()) {
-    n.children.sort(sortByOrder);
-  }
-  return {
-    runId,
-    name: rs.name,
-    status: runStatus,
-    durationMs,
-    steps: roots
-  };
-}
-
-// packages/core/src/diff/engine.ts
-var DEFAULT_THRESHOLD_MS = 0;
-function pathSeg(step, index) {
-  return { index, name: step.name, stepId: step.id };
-}
-function buildPath(segments) {
-  return { path: [...segments] };
-}
-function pairSteps(left, right) {
-  const usedRight = /* @__PURE__ */ new Set();
-  const pairs = [];
-  for (let i = 0; i < left.length; i++) {
-    const L = left[i];
-    let R = right.find((r) => !usedRight.has(r.id) && r.id === L.id);
-    if (R === void 0 && i < right.length && !usedRight.has(right[i].id)) {
-      const cand = right[i];
-      if (cand.name === L.name && (cand.type ?? "") === (L.type ?? "")) {
-        R = cand;
-      }
-    }
-    if (R === void 0) {
-      R = right.find(
-        (r) => !usedRight.has(r.id) && r.name === L.name && (r.type ?? "") === (L.type ?? "")
-      );
-    }
-    if (R !== void 0) {
-      usedRight.add(R.id);
-      pairs.push([L, R]);
-    } else {
-      pairs.push([L, void 0]);
-    }
-  }
-  for (const R of right) {
-    if (!usedRight.has(R.id)) {
-      pairs.push([void 0, R]);
-    }
-  }
-  return pairs;
-}
-function compareLeafSteps(L, R, segments, opts, out) {
-  const path16 = buildPath(segments);
-  if (L.name !== R.name) {
-    out.push({
-      kind: "structure",
-      severity: "warning",
-      message: "Step name differs",
-      path: path16,
-      left: L.name,
-      right: R.name
-    });
-  }
-  if ((L.type ?? "") !== (R.type ?? "")) {
-    out.push({
-      kind: "step-type",
-      severity: "warning",
-      message: "Step type differs",
-      path: path16,
-      left: L.type,
-      right: R.type
-    });
-  }
-  if ((L.status ?? "") !== (R.status ?? "")) {
-    out.push({
-      kind: "step-status",
-      severity: "warning",
-      message: "Step status differs",
-      path: path16,
-      left: L.status,
-      right: R.status
-    });
-  }
-  const le = L.error ?? "";
-  const re = R.error ?? "";
-  if (le !== re) {
-    out.push({
-      kind: "error",
-      severity: "error",
-      message: "Step error message differs",
-      path: path16,
-      left: le || void 0,
-      right: re || void 0
-    });
-  }
-  if (!opts.ignoreDuration) {
-    const ld = L.durationMs;
-    const rd = R.durationMs;
-    const th = opts.durationThresholdMs;
-    let differs = false;
-    if (ld === void 0 && rd === void 0) differs = false;
-    else if (ld === void 0 || rd === void 0) differs = true;
-    else differs = Math.abs(ld - rd) > th;
-    if (differs) {
-      out.push({
-        kind: "duration",
-        severity: "info",
-        message: "Step duration differs",
-        path: path16,
-        left: ld,
-        right: rd
-      });
-    }
-  }
-  const lm = stableJson(L.metadata ?? {});
-  const rm2 = stableJson(R.metadata ?? {});
-  if (lm !== rm2) {
-    out.push({
-      kind: "metadata",
-      severity: "info",
-      message: "Step metadata differs",
-      path: path16,
-      left: L.metadata,
-      right: R.metadata
-    });
-  }
-  const lo = stableJson(L.outputPreview ?? null);
-  const ro = stableJson(R.outputPreview ?? null);
-  if (lo !== ro) {
-    out.push({
-      kind: "output",
-      severity: "info",
-      message: "Output preview differs",
-      path: path16,
-      left: L.outputPreview,
-      right: R.outputPreview
-    });
-  }
-}
-function compareRecursive(L, R, segments, opts, out) {
-  compareLeafSteps(L, R, segments, opts, out);
-  const pairs = pairSteps(L.children, R.children);
-  let ci = 0;
-  for (const [lch, rch] of pairs) {
-    if (lch !== void 0 && rch !== void 0) {
-      compareRecursive(lch, rch, [...segments, pathSeg(lch, ci)], opts, out);
-    } else if (lch !== void 0) {
-      out.push({
-        kind: "step-removed",
-        severity: "warning",
-        message: `Step only in left run: ${lch.name}`,
-        path: buildPath([...segments, pathSeg(lch, ci)]),
-        left: lch.id,
-        right: void 0
-      });
-    } else if (rch !== void 0) {
-      out.push({
-        kind: "step-added",
-        severity: "warning",
-        message: `Step only in right run: ${rch.name}`,
-        path: buildPath([...segments, pathSeg(rch, ci)]),
-        left: void 0,
-        right: rch.id
-      });
-    }
-    ci += 1;
-  }
-}
-function mergeDiffDefaults(options) {
-  return {
-    ignoreDuration: false,
-    durationThresholdMs: DEFAULT_THRESHOLD_MS,
-    focus: "all",
-    check: "all"
-  };
-}
-function kindMatchesFilter(kind, merged) {
-  return true;
-}
-function diffRuns(left, right, options) {
-  const merged = mergeDiffDefaults();
-  const opts = {
-    ignoreDuration: merged.ignoreDuration,
-    durationThresholdMs: merged.durationThresholdMs
-  };
-  const raw = [];
-  if ((left.status ?? "") !== (right.status ?? "")) {
-    raw.push({
-      kind: "run-status",
-      severity: "warning",
-      message: "Run completion status differs",
-      left: left.status,
-      right: right.status
-    });
-  }
-  {
-    const ld = left.durationMs;
-    const rd = right.durationMs;
-    const th = merged.durationThresholdMs;
-    let differs = false;
-    if (ld === void 0 && rd === void 0) differs = false;
-    else if (ld === void 0 || rd === void 0) differs = true;
-    else differs = Math.abs(ld - rd) > th;
-    if (differs) {
-      raw.push({
-        kind: "duration",
-        severity: "info",
-        message: "Run duration differs",
-        left: ld,
-        right: rd
-      });
-    }
-  }
-  const pairs = pairSteps(left.steps, right.steps);
-  let idx = 0;
-  for (const [ls, rs] of pairs) {
-    if (ls !== void 0 && rs !== void 0) {
-      compareRecursive(ls, rs, [pathSeg(ls, idx)], opts, raw);
-      idx += 1;
-    } else if (ls !== void 0) {
-      raw.push({
-        kind: "step-removed",
-        severity: "warning",
-        message: `Step only in left run: ${ls.name}`,
-        path: buildPath([pathSeg(ls, idx)]),
-        left: ls.id,
-        right: void 0
-      });
-      idx += 1;
-    } else if (rs !== void 0) {
-      raw.push({
-        kind: "step-added",
-        severity: "warning",
-        message: `Step only in right run: ${rs.name}`,
-        path: buildPath([pathSeg(rs, idx)]),
-        left: void 0,
-        right: rs.id
-      });
-      idx += 1;
-    }
-  }
-  const differences = raw.filter((d) => kindMatchesFilter(d.kind));
-  let errors = 0;
-  let warnings = 0;
-  let info = 0;
-  for (const d of differences) {
-    if (d.severity === "error") errors += 1;
-    else if (d.severity === "warning") warnings += 1;
-    else info += 1;
-  }
-  const firstVisible = differences[0];
-  const firstDivergence = firstVisible !== void 0 ? {
-    kind: "first-divergence",
-    severity: firstVisible.severity,
-    message: `First divergence: ${firstVisible.message}`,
-    path: firstVisible.path,
-    left: firstVisible.left,
-    right: firstVisible.right
-  } : void 0;
-  const summary = {
-    leftRunId: left.runId,
-    rightRunId: right.runId,
-    totalDifferences: differences.length,
-    errors,
-    warnings,
-    info,
-    firstDivergence
-  };
-  return { summary, differences };
-}
-
-// packages/viewer/src/suite-data.ts
 async function enrichCase(suiteCase, baselineTracePath) {
   const base = {
     id: suiteCase.id,
@@ -5162,7 +5173,7 @@ async function loadSuiteViewerData(options) {
   for (const suiteCase of result.cases) {
     cases.push(await enrichCase(suiteCase, baselinePath));
   }
-  const artifactsDir = path13__default.default.join(path13__default.default.dirname(result.configPath), ".agent-inspect/suite-runs");
+  const artifactsDir = path15__default.default.join(path15__default.default.dirname(result.configPath), ".agent-inspect/suite-runs");
   return {
     suiteName: result.suiteName,
     configPath: result.configPath,
@@ -5323,19 +5334,19 @@ function parseWorkspaceManifest(json) {
 }
 var INDEX_DIR_NAME = "index";
 function resolveWorkspaceLocation(cwd = process.cwd()) {
-  const projectRoot = path13__default.default.resolve(cwd);
-  const workspaceDir = path13__default.default.join(projectRoot, WORKSPACE_DIR_NAME);
+  const projectRoot = path15__default.default.resolve(cwd);
+  const workspaceDir = path15__default.default.join(projectRoot, WORKSPACE_DIR_NAME);
   return {
     projectRoot,
     workspaceDir,
-    manifestPath: path13__default.default.join(workspaceDir, WORKSPACE_MANIFEST_FILENAME)
+    manifestPath: path15__default.default.join(workspaceDir, WORKSPACE_MANIFEST_FILENAME)
   };
 }
 function resolveInsideWorkspace(workspaceDir, relative) {
-  const base = path13__default.default.resolve(workspaceDir);
-  const resolved = path13__default.default.resolve(base, relative);
-  const rel = path13__default.default.relative(base, resolved);
-  if (rel === "" || rel === "." || !rel.startsWith("..") && !path13__default.default.isAbsolute(rel)) {
+  const base = path15__default.default.resolve(workspaceDir);
+  const resolved = path15__default.default.resolve(base, relative);
+  const rel = path15__default.default.relative(base, resolved);
+  if (rel === "" || rel === "." || !rel.startsWith("..") && !path15__default.default.isAbsolute(rel)) {
     return resolved;
   }
   throw new Error(
@@ -5479,7 +5490,7 @@ async function doctorWorkspace(location) {
     const abs = resolveInsideWorkspace(location.workspaceDir, rel);
     for (const file of await listJsonl(abs)) {
       try {
-        const s = await promises.stat(path13__default.default.join(abs, file));
+        const s = await promises.stat(path15__default.default.join(abs, file));
         newestTraceMtime = Math.max(newestTraceMtime, s.mtimeMs);
       } catch {
         checks.push({ id: "trace-readability", status: "warn", message: `cannot stat ${rel}/${file}` });
@@ -5509,7 +5520,7 @@ async function doctorWorkspace(location) {
 
 // packages/viewer/src/workspace-data.ts
 async function loadWorkspaceViewerData(options) {
-  const cwd = path13__default.default.resolve(options.cwd ?? process.cwd());
+  const cwd = path15__default.default.resolve(options.cwd ?? process.cwd());
   const location = resolveWorkspaceLocation(cwd);
   const manifestRead = await readWorkspaceManifestFile(location);
   if (!manifestRead.ok || manifestRead.manifest === void 0) {
@@ -5522,7 +5533,7 @@ async function loadWorkspaceViewerData(options) {
   const runs = [];
   for (const rel of manifestRead.manifest.traceDirs) {
     const traceDir = resolveTraceDir({
-      dir: path13__default.default.join(location.workspaceDir, rel)
+      dir: path15__default.default.join(location.workspaceDir, rel)
     });
     const td = new TraceDirectory({ dir: traceDir });
     const files = await td.list();
@@ -5536,7 +5547,7 @@ async function loadWorkspaceViewerData(options) {
         runId: meta.runId,
         ...meta.name !== void 0 ? { name: meta.name } : {},
         status: meta.status,
-        file: path13__default.default.basename(meta.filePath)
+        file: path15__default.default.basename(meta.filePath)
       });
     }
   }
@@ -5547,8 +5558,8 @@ async function loadWorkspaceViewerData(options) {
     doctor,
     runs,
     bundleDirs: [
-      path13__default.default.join(location.workspaceDir, manifestRead.manifest.bundlesDir),
-      path13__default.default.join(location.workspaceDir, manifestRead.manifest.artifactsDir)
+      path15__default.default.join(location.workspaceDir, manifestRead.manifest.bundlesDir),
+      path15__default.default.join(location.workspaceDir, manifestRead.manifest.artifactsDir)
     ]
   };
 }
@@ -5611,7 +5622,7 @@ function createViewerServer(options = {}) {
           ok: true,
           readOnly: true,
           mode,
-          traceDir: path13__default.default.resolve(traceDir)
+          traceDir: path15__default.default.resolve(traceDir)
         });
       }
       if (pathname === "/api/suite" && mode === "suite") {
@@ -5640,7 +5651,7 @@ function createViewerServer(options = {}) {
             runId: meta.runId,
             name: meta.name,
             status: meta.status,
-            file: path13__default.default.basename(meta.filePath),
+            file: path15__default.default.basename(meta.filePath),
             startedAt: meta.startedAt,
             durationMs: meta.durationMs
           }))
@@ -5757,7 +5768,7 @@ function startViewerServer(options = {}) {
       resolve({
         host,
         port: resolvedPort,
-        traceDir: path13__default.default.resolve(traceDir),
+        traceDir: path15__default.default.resolve(traceDir),
         url: `http://${host}:${resolvedPort}/${modeQuery}`,
         mode
       });