@agent-inspect/viewer 5.1.0 → 5.3.0

package/dist/index.mjs

@@ -1,14 +1,14 @@
 import { createServer } from 'http';
-import path11 from 'path';
+import path13 from 'path';
 import { AsyncLocalStorage } from 'async_hooks';
 import 'crypto';
-import { readdir, stat, readFile } from 'fs/promises';
+import { readFile, stat, readdir, access } from 'fs/promises';
 import os from 'os';
 import 'nanoid';
 import 'chalk';
-import 'fs';
+import { constants } from 'fs';
 import 'readline';
-import 'url';
+import { pathToFileURL } from 'url';
 
 // packages/viewer/src/server.ts
 
@@ -518,7 +518,7 @@ function persistedInspectEventsToTraceEvents(events, options) {
 }
 var DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
 var RUNS_DIR_NAME = "runs";
-var FALLBACK_TRACE_DIR = path11.join(
+var FALLBACK_TRACE_DIR = path13.join(
   os.tmpdir(),
   "agent-inspect",
   RUNS_DIR_NAME
@@ -533,11 +533,20 @@ function getDefaultTraceDir() {
     if (typeof home !== "string" || home.trim() === "") {
       return FALLBACK_TRACE_DIR;
     }
-    return path11.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
+    return path13.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
   } catch {
     return FALLBACK_TRACE_DIR;
   }
 }
+function getTraceFilePath(runId, traceDir) {
+  const baseDir = traceDir ?? getDefaultTraceDir();
+  let safeId = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "run_unknown";
+  safeId = path13.basename(safeId);
+  if (safeId === "" || safeId === "." || safeId === "..") {
+    safeId = "run_unknown";
+  }
+  return path13.join(baseDir, `${safeId}.jsonl`);
+}
 function formatError(error) {
   if (error instanceof Error) {
     const out = { message: error.message };
@@ -726,6 +735,78 @@ async function readTraceEventsFromFile(filePath) {
 
 // packages/core/src/context.ts
 new AsyncLocalStorage();
+
+// packages/core/src/outcomes/types.ts
+var OUTCOME_ATTRIBUTE_STATUS_KEY = "outcomeStatus";
+var OUTCOME_ATTRIBUTE_EXPECTATION_KEY = "expectation";
+var OUTCOME_ATTRIBUTE_METHOD_KEY = "method";
+var OUTCOME_ATTRIBUTE_OBSERVED_AT_KEY = "observedAt";
+var OUTCOME_LEGACY_EVENT = "outcome_observed";
+
+// packages/core/src/outcomes/extract.ts
+function isOutcomeStatus(value) {
+  return value === "passed" || value === "failed" || value === "unknown" || value === "skipped";
+}
+function parseMethod(value) {
+  if (typeof value !== "string" || value.trim() === "") return void 0;
+  return value;
+}
+function fromOutcomeObservedEvent(event) {
+  return {
+    outcomeId: event.outcomeId,
+    runId: event.runId,
+    ...event.parentId !== void 0 ? { parentId: event.parentId } : {},
+    name: event.name,
+    expectation: event.expectation,
+    status: event.status,
+    ...event.method !== void 0 ? { method: event.method } : {},
+    ...event.actual !== void 0 ? { actual: event.actual } : {},
+    ...event.evidence !== void 0 ? { evidence: event.evidence } : {},
+    observedAt: event.observedAt
+  };
+}
+function fromPersistedOutcome(event) {
+  if (event.kind !== "OUTCOME") return void 0;
+  const attrs = event.attributes ?? {};
+  const statusRaw = attrs[OUTCOME_ATTRIBUTE_STATUS_KEY];
+  if (!isOutcomeStatus(statusRaw)) return void 0;
+  const expectation = typeof attrs[OUTCOME_ATTRIBUTE_EXPECTATION_KEY] === "string" ? attrs[OUTCOME_ATTRIBUTE_EXPECTATION_KEY] : event.name;
+  const observedAtRaw = attrs[OUTCOME_ATTRIBUTE_OBSERVED_AT_KEY];
+  const observedAt = typeof observedAtRaw === "string" ? Date.parse(observedAtRaw) : typeof observedAtRaw === "number" && Number.isFinite(observedAtRaw) ? observedAtRaw : Date.parse(event.timestamp);
+  return {
+    outcomeId: event.eventId,
+    runId: event.runId,
+    ...event.parentId !== void 0 ? { parentId: event.parentId } : {},
+    name: event.name,
+    expectation,
+    status: statusRaw,
+    ...parseMethod(attrs[OUTCOME_ATTRIBUTE_METHOD_KEY]) !== void 0 ? { method: parseMethod(attrs[OUTCOME_ATTRIBUTE_METHOD_KEY]) } : {},
+    ...event.outputSummary !== void 0 ? { actual: event.outputSummary } : {},
+    ...attrs.evidence !== void 0 ? { evidence: attrs.evidence } : {},
+    observedAt: Number.isFinite(observedAt) ? observedAt : Date.parse(event.timestamp)
+  };
+}
+function extractOutcomesFromTraceEvents(events) {
+  const out = [];
+  for (const event of events) {
+    if (event.event === OUTCOME_LEGACY_EVENT) {
+      out.push(fromOutcomeObservedEvent(event));
+    }
+  }
+  return out.sort((a, b) => a.observedAt - b.observedAt || a.name.localeCompare(b.name));
+}
+function extractOutcomesFromPersistedEvents(events) {
+  const out = [];
+  for (const event of events) {
+    const outcome = fromPersistedOutcome(event);
+    if (outcome) out.push(outcome);
+  }
+  return out.sort((a, b) => a.observedAt - b.observedAt || a.name.localeCompare(b.name));
+}
+function outcomesMatchingStatus(outcomes, statuses) {
+  const set = new Set(statuses);
+  return outcomes.filter((outcome) => set.has(outcome.status));
+}
 function resolveTraceDir(options = {}) {
   if (typeof options.dir === "string" && options.dir.trim() !== "") {
     return options.dir.trim();
@@ -742,7 +823,7 @@ var TraceDirectory = class {
     this.#dir = resolveTraceDir(options);
   }
   getPath(filename) {
-    return filename ? path11.join(this.#dir, filename) : this.#dir;
+    return filename ? path13.join(this.#dir, filename) : this.#dir;
   }
   async list() {
     try {
@@ -769,7 +850,7 @@ function parseIsoToMs2(value) {
 }
 async function extractMetadata(filePath, _quickScan) {
   const stats = await stat(filePath);
-  let runIdFromFile = path11.basename(filePath);
+  let runIdFromFile = path13.basename(filePath);
   if (runIdFromFile.endsWith(".jsonl")) {
     runIdFromFile = runIdFromFile.slice(0, -".jsonl".length);
   }
@@ -1379,12 +1460,12 @@ function buildCriticalPath(runs, handoffs) {
     handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.from)
   );
   const ordered = [...runs].sort(compareRuns);
-  const path12 = [];
+  const path16 = [];
   const visited = /* @__PURE__ */ new Set();
   const pushRun = (run, confidence, source) => {
     if (visited.has(run.runId)) return;
     visited.add(run.runId);
-    path12.push({
+    path16.push({
       runId: run.runId,
       name: run.name,
       startedAt: run.startedAt,
@@ -1409,7 +1490,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 path12;
+  return path16;
 }
 function metaRunIdMatches(run, token, runById) {
   const meta = extractSessionWorkflowMetadata(run.metadata);
@@ -1486,6 +1567,264 @@ 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.`);
+  }
+  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 = [];
+  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 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("; "));
+    }
+    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}".`);
+    }
+    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;
+}
+
+// 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" };
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveSuiteConfigPath(options = {}) {
+  const cwd = path13.resolve(options.cwd ?? process.cwd());
+  if (options.configPath !== void 0 && options.configPath.trim() !== "") {
+    return path13.resolve(cwd, options.configPath.trim());
+  }
+  for (const name of DEFAULT_SUITE_CONFIG_NAMES) {
+    const candidate = path13.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.`
+  );
+}
+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 = path13.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 readFile(configPath, "utf-8"));
+    } else {
+      const mod = await import(pathToFileURL(configPath).href);
+      raw = "default" in mod ? mod.default : mod;
+    }
+    const config = normalizeSuiteConfig(raw);
+    return {
+      config,
+      configPath,
+      configDir: path13.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 access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveSuiteCaseTrace(suiteCase, options) {
+  if (suiteCase.trace !== void 0) {
+    const tracePath = path13.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 = path13.join(options.tracesDir, `${path13.basename(runKey)}.jsonl`);
+  if (await exists(nestedPath)) {
+    return { caseId: suiteCase.id, tracePath: nestedPath, runId: runKey, missing: false };
+  }
+  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,
@@ -1500,7 +1839,7 @@ var STATUS_RANK = {
 function compareStrings(a, b) {
   return (a ?? "").localeCompare(b ?? "");
 }
-function diagnostic(code, message, ruleId) {
+function diagnostic3(code, message, ruleId) {
   return {
     code,
     message,
@@ -1566,7 +1905,7 @@ function resolveSelectedRun(input, runId) {
     if (runId && input.selectedRun.runId !== runId) {
       return {
         diagnostics: [
-          diagnostic(
+          diagnostic3(
             "AI_CHECK_INVALID_ARGUMENTS",
             `Selected run ${input.selectedRun.runId} does not match requested run ${runId}.`
           )
@@ -1580,7 +1919,7 @@ function resolveSelectedRun(input, runId) {
     if (!run) {
       return {
         diagnostics: [
-          diagnostic("AI_CHECK_RUN_SELECTION_REQUIRED", `Run not found: ${runId}.`)
+          diagnostic3("AI_CHECK_RUN_SELECTION_REQUIRED", `Run not found: ${runId}.`)
         ]
       };
     }
@@ -1592,13 +1931,13 @@ function resolveSelectedRun(input, runId) {
   if (input.read.runs.length === 0) {
     return {
       diagnostics: [
-        diagnostic("AI_CHECK_RUN_SELECTION_REQUIRED", "No runs are available for checks.")
+        diagnostic3("AI_CHECK_RUN_SELECTION_REQUIRED", "No runs are available for checks.")
       ]
     };
   }
   return {
     diagnostics: [
-      diagnostic(
+      diagnostic3(
         "AI_CHECK_RUN_SELECTION_REQUIRED",
         "Multiple runs are available; select a run before executing checks."
       )
@@ -1611,7 +1950,7 @@ function selectRules(rules, selectedIds) {
   for (const rule of rules) {
     if (byId.has(rule.id)) {
       diagnostics.push(
-        diagnostic("AI_CHECK_INVALID_CONFIG", `Duplicate trace check rule id: ${rule.id}.`, rule.id)
+        diagnostic3("AI_CHECK_INVALID_CONFIG", `Duplicate trace check rule id: ${rule.id}.`, rule.id)
       );
       continue;
     }
@@ -1622,7 +1961,7 @@ function selectRules(rules, selectedIds) {
     for (const id of selected) {
       if (!byId.has(id)) {
         diagnostics.push(
-          diagnostic("AI_CHECK_INVALID_CONFIG", `Unknown trace check rule id: ${id}.`, id)
+          diagnostic3("AI_CHECK_INVALID_CONFIG", `Unknown trace check rule id: ${id}.`, id)
         );
       }
     }
@@ -1682,7 +2021,20 @@ function summarize(findings, diagnostics) {
     errors: diagnostics.filter((item) => item.severity === "error").length
   };
 }
-function eventEvidence(event, path12) {
+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, path16) {
   return {
     runId: event.runId,
     eventId: event.eventId,
@@ -1692,7 +2044,7 @@ function eventEvidence(event, path12) {
     kind: event.kind,
     name: event.name,
     status: event.status,
-    ...{}
+    ...path16 ? { path: path16 } : {}
   };
 }
 function runEvidence(run) {
@@ -1709,6 +2061,23 @@ function failFinding(ruleId, message, evidence, expected, 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";
   const allowIncomplete = options.allowIncomplete === true;
@@ -1748,6 +2117,180 @@ function createRunStatusRule(options = {}) {
     }
   };
 }
+function createRunDurationRule(options) {
+  return {
+    id: "run.duration",
+    category: "run",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const actual = context.selectedRun?.durationMs;
+      if (actual === void 0 || actual <= options.maxDurationMs) return [];
+      return [
+        failFinding(
+          "run.duration",
+          `Run duration ${actual}ms exceeded ${options.maxDurationMs}ms.`,
+          runEvidence(context.selectedRun),
+          { maxDurationMs: options.maxDurationMs },
+          actual
+        )
+      ];
+    }
+  };
+}
+function createToolUsageRule(options) {
+  return {
+    id: "tool.usage",
+    category: "tool",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const tools = finishedEvents(context, "TOOL");
+      const names = tools.map(toolName);
+      const nameSet = new Set(names);
+      const findings = [];
+      for (const required of options.required ?? []) {
+        if (!nameSet.has(required)) {
+          findings.push(
+            failFinding("tool.usage", `Required tool ${required} did not appear.`, runEvidence(context.selectedRun), required, names)
+          );
+        }
+      }
+      const forbidden = new Set(options.forbidden ?? []);
+      const allowed = options.allowed ? new Set(options.allowed) : void 0;
+      for (const event of tools) {
+        const name = toolName(event);
+        if (forbidden.has(name)) {
+          findings.push(
+            failFinding("tool.usage", `Forbidden tool ${name} appeared.`, [eventEvidence(event)], "tool absent", name)
+          );
+        }
+        if (allowed && !allowed.has(name)) {
+          findings.push(
+            failFinding("tool.usage", `Tool ${name} is not in the allowed tool set.`, [eventEvidence(event)], [...allowed].sort(), name)
+          );
+        }
+      }
+      if (options.minCount !== void 0 && tools.length < options.minCount) {
+        findings.push(
+          failFinding("tool.usage", `Tool count ${tools.length} was below minimum ${options.minCount}.`, runEvidence(context.selectedRun), { minCount: options.minCount }, tools.length)
+        );
+      }
+      if (options.maxCount !== void 0 && tools.length > options.maxCount) {
+        findings.push(
+          failFinding("tool.usage", `Tool count ${tools.length} exceeded maximum ${options.maxCount}.`, tools.map((event) => eventEvidence(event)), { maxCount: options.maxCount }, tools.length)
+        );
+      }
+      return findings;
+    }
+  };
+}
+function createLlmUsageRule(options) {
+  return {
+    id: "llm.usage",
+    category: "llm",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const llms = finishedEvents(context, "LLM");
+      const findings = [];
+      const allowedModels = options.allowedModels ? new Set(options.allowedModels) : void 0;
+      const allowedProviders = options.allowedProviders ? new Set(options.allowedProviders) : void 0;
+      const finishReasons = options.finishReasons ? new Set(options.finishReasons) : void 0;
+      if (options.maxCalls !== void 0 && llms.length > options.maxCalls) {
+        findings.push(
+          failFinding(
+            "llm.usage",
+            `LLM call count ${llms.length} exceeded ${options.maxCalls}.`,
+            llms.map((event) => eventEvidence(event)),
+            { maxCalls: options.maxCalls },
+            llms.length
+          )
+        );
+      }
+      for (const event of llms) {
+        const model = llmModel(event);
+        const provider = llmProvider(event);
+        const finishReason = llmFinishReason(event);
+        if (allowedModels && (!model || !allowedModels.has(model))) {
+          findings.push(
+            failFinding("llm.usage", `LLM model ${model ?? "unknown"} is not allowed.`, [eventEvidence(event, "attributes.model")], [...allowedModels].sort(), model ?? "unknown")
+          );
+        }
+        if (allowedProviders && (!provider || !allowedProviders.has(provider))) {
+          findings.push(
+            failFinding("llm.usage", `LLM provider ${provider ?? "unknown"} is not allowed.`, [eventEvidence(event, "attributes.provider")], [...allowedProviders].sort(), provider ?? "unknown")
+          );
+        }
+        if (finishReasons && (!finishReason || !finishReasons.has(finishReason))) {
+          findings.push(
+            failFinding("llm.usage", `LLM finish reason ${finishReason ?? "unknown"} is not allowed.`, [eventEvidence(event, "attributes.finishReason")], [...finishReasons].sort(), finishReason ?? "unknown")
+          );
+        }
+      }
+      const tokenTotals = llms.reduce(
+        (totals, event) => ({
+          input: totals.input + (event.tokenUsage?.input ?? 0),
+          output: totals.output + (event.tokenUsage?.output ?? 0),
+          total: totals.total + (event.tokenUsage?.total ?? 0),
+          cached: totals.cached + (event.tokenUsage?.cached ?? 0)
+        }),
+        { input: 0, output: 0, total: 0, cached: 0 }
+      );
+      const tokenLimits = [
+        ["input", options.maxInputTokens],
+        ["output", options.maxOutputTokens],
+        ["total", options.maxTotalTokens],
+        ["cached", options.maxCachedTokens]
+      ];
+      for (const [key, limit] of tokenLimits) {
+        if (limit !== void 0 && tokenTotals[key] > limit) {
+          findings.push(
+            failFinding(
+              "llm.usage",
+              `LLM ${key} token count ${tokenTotals[key]} exceeded ${limit}.`,
+              llms.map((event) => eventEvidence(event, `tokenUsage.${key}`)),
+              { [`max${key[0].toUpperCase()}${key.slice(1)}Tokens`]: limit },
+              tokenTotals[key]
+            )
+          );
+        }
+      }
+      return findings;
+    }
+  };
+}
+function createObservedOutcomeRule(options = {}) {
+  const failOn = options.failOn ?? ["failed"];
+  return {
+    id: "outcome.status",
+    category: "run",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const outcomes = extractOutcomesFromPersistedEvents(context.events);
+      const matching = outcomesMatchingStatus(outcomes, failOn);
+      if (matching.length === 0) return [];
+      return [
+        failFinding(
+          "outcome.status",
+          `Observed outcome count ${matching.length} matched [${failOn.join(", ")}].`,
+          matching.map((outcome) => ({
+            runId: outcome.runId,
+            eventId: outcome.outcomeId,
+            ...outcome.parentId !== void 0 ? { parentId: outcome.parentId } : {},
+            kind: "OUTCOME",
+            name: outcome.name,
+            status: outcome.status,
+            path: `outcome.${outcome.name}`
+          })),
+          { failOn },
+          matching.map((outcome) => ({
+            name: outcome.name,
+            status: outcome.status,
+            expectation: outcome.expectation
+          }))
+        )
+      ];
+    }
+  };
+}
 function runTraceChecks(input, options = {}) {
   const selected = resolveSelectedRun(input, options.runId);
   if (selected.diagnostics.length > 0) {
@@ -1771,7 +2314,7 @@ function runTraceChecks(input, options = {}) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       diagnostics.push(
-        diagnostic("AI_CHECK_INTERNAL_ERROR", `Rule ${rule.id} failed: ${message}`, rule.id)
+        diagnostic3("AI_CHECK_INTERNAL_ERROR", `Rule ${rule.id} failed: ${message}`, rule.id)
       );
     }
   }
@@ -2410,7 +2953,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) => path11.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path13.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
 }
 async function resolveInput(input) {
   const cached = resolvedInputCache.get(input);
@@ -3861,6 +4404,225 @@ function openTrace(input, options = {}) {
   return readTrace(input, options);
 }
 
+// packages/core/src/suite/run.ts
+function diagnostic4(code, message, severity = "error", caseId) {
+  return { code, message, severity, ...caseId !== void 0 ? { caseId } : {} };
+}
+function buildCaseRules(suiteCase, config) {
+  const rules = [];
+  const select = new Set(config.checks?.select ?? []);
+  if (select.has("run.status")) {
+    rules.push(createRunStatusRule());
+  }
+  const requiredTools = [
+    ...config.checks?.tool?.required ?? [],
+    ...suiteCase.requireTools ?? []
+  ];
+  const forbiddenTools = [
+    ...config.checks?.tool?.forbidden ?? [],
+    ...suiteCase.forbidTools ?? []
+  ];
+  if (requiredTools.length > 0 || forbiddenTools.length > 0) {
+    rules.push(
+      createToolUsageRule({
+        required: requiredTools.length > 0 ? requiredTools : void 0,
+        forbidden: forbiddenTools.length > 0 ? forbiddenTools : void 0
+      })
+    );
+    select.add("tool.usage");
+  }
+  const maxDurationMs = suiteCase.maxDurationMs ?? config.checks?.run?.maxDurationMs ?? config.eval?.maxDurationMs;
+  if (maxDurationMs !== void 0) {
+    rules.push(createRunDurationRule({ maxDurationMs }));
+    select.add("run.duration");
+  }
+  const llm = config.checks?.llm;
+  if (llm?.allowedModels !== void 0 || llm?.maxTotalTokens !== void 0) {
+    rules.push(createLlmUsageRule(llm));
+    select.add("llm.usage");
+  }
+  if (select.has("outcome.status")) {
+    rules.push(createObservedOutcomeRule({ failOn: ["failed"] }));
+  }
+  return { rules, select: [...select] };
+}
+function outcomesFromRead(read) {
+  const persistedOutcomes = extractOutcomesFromPersistedEvents(
+    read.events.filter((event) => event.kind === "OUTCOME")
+  );
+  if (persistedOutcomes.length > 0) return persistedOutcomes;
+  const traceEvents = [];
+  for (const event of read.events) {
+    const legacy = event;
+    if (typeof legacy === "object" && legacy !== null && "event" in legacy && legacy.event === "outcome_observed") {
+      traceEvents.push(legacy);
+    }
+  }
+  return traceEvents.length > 0 ? extractOutcomesFromTraceEvents(traceEvents) : [];
+}
+function validateExpectedObservations(suiteCase, read) {
+  const expected = suiteCase.expectedObservations ?? [];
+  if (expected.length === 0) return { ok: true, diagnostics: [] };
+  const outcomes = outcomesFromRead(read);
+  const diagnostics = [];
+  for (const name of expected) {
+    const match = outcomes.find((outcome) => outcome.name === name);
+    if (!match) {
+      diagnostics.push(
+        diagnostic4(
+          "AI_SUITE_CASE_OBSERVATION_FAILED",
+          `Expected observation "${name}" was not recorded.`,
+          "error",
+          suiteCase.id
+        )
+      );
+      continue;
+    }
+    if (match.status !== "passed") {
+      diagnostics.push(
+        diagnostic4(
+          "AI_SUITE_CASE_OBSERVATION_FAILED",
+          `Observation "${name}" has status "${match.status}", expected "passed".`,
+          "error",
+          suiteCase.id
+        )
+      );
+    }
+  }
+  return { ok: diagnostics.length === 0, diagnostics };
+}
+async function runSuiteCase(suiteCase, config, options) {
+  const resolved = await resolveSuiteCaseTrace(suiteCase, options);
+  if (resolved.missing || resolved.tracePath === void 0) {
+    return {
+      id: suiteCase.id,
+      status: "skipped",
+      ...resolved.runId !== void 0 ? { runId: resolved.runId } : {},
+      message: resolved.reason,
+      diagnostics: [
+        diagnostic4(
+          "AI_SUITE_CASE_TRACE_MISSING",
+          resolved.reason ?? "Trace not found.",
+          "warning",
+          suiteCase.id
+        )
+      ]
+    };
+  }
+  let read;
+  try {
+    read = await openTrace({ type: "file", path: resolved.tracePath });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      id: suiteCase.id,
+      status: "error",
+      tracePath: resolved.tracePath,
+      ...resolved.runId !== void 0 ? { runId: resolved.runId } : {},
+      message,
+      diagnostics: [
+        diagnostic4("AI_SUITE_TRACE_UNREADABLE", message, "error", suiteCase.id)
+      ]
+    };
+  }
+  const { rules, select } = buildCaseRules(suiteCase, config);
+  const checkResult = rules.length > 0 ? runTraceChecks({ read }, { rules, select }) : {
+    ok: true,
+    status: "pass",
+    format: read.format,
+    findings: [],
+    diagnostics: []
+  };
+  const observationResult = validateExpectedObservations(suiteCase, read);
+  const diagnostics = [
+    ...checkResult.diagnostics.map(
+      (item) => diagnostic4(
+        "AI_SUITE_CASE_CHECK_FAILED",
+        item.message,
+        item.severity,
+        suiteCase.id
+      )
+    ),
+    ...checkResult.findings.filter((finding) => finding.status === "fail").map(
+      (finding) => diagnostic4(
+        "AI_SUITE_CASE_CHECK_FAILED",
+        finding.message,
+        finding.severity,
+        suiteCase.id
+      )
+    ),
+    ...observationResult.diagnostics
+  ];
+  const checkOk = checkResult.ok;
+  const observationsOk = observationResult.ok;
+  const ok = checkOk && observationsOk;
+  const status = ok ? "pass" : checkResult.status === "error" ? "error" : "fail";
+  return {
+    id: suiteCase.id,
+    status,
+    tracePath: resolved.tracePath,
+    ...resolved.runId !== void 0 ? { runId: resolved.runId } : {},
+    checkOk,
+    observationsOk,
+    diagnostics,
+    ...ok ? {} : {
+      message: diagnostics.map((item) => item.message).join("; ") || checkResult.findings.map((item) => item.message).join("; ")
+    }
+  };
+}
+async function runSuite(options = {}) {
+  const startedAt = new Date(options.nowMs ?? Date.now()).toISOString();
+  const { config, configPath, configDir } = await loadSuiteConfig(options);
+  const tracesDir = path13.resolve(configDir, config.traces);
+  const cases = [];
+  const diagnostics = [];
+  for (const suiteCase of config.cases) {
+    cases.push(
+      await runSuiteCase(suiteCase, config, {
+        configDir,
+        tracesDir
+      })
+    );
+  }
+  const summary = {
+    passed: cases.filter((item) => item.status === "pass").length,
+    failed: cases.filter((item) => item.status === "fail").length,
+    errors: cases.filter((item) => item.status === "error").length,
+    skipped: cases.filter((item) => item.status === "skipped").length
+  };
+  const finishedAt = new Date(options.nowMs ?? Date.now()).toISOString();
+  const ok = summary.failed === 0 && summary.errors === 0;
+  const status = summary.errors > 0 ? "error" : summary.failed > 0 || !ok ? "fail" : "pass";
+  return {
+    ok,
+    status,
+    suiteName: config.name,
+    configPath,
+    tracesDir,
+    startedAt,
+    finishedAt,
+    summary,
+    cases,
+    diagnostics
+  };
+}
+
+// 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">
@@ -3870,20 +4632,71 @@ var viewerIndexHtml = `<!DOCTYPE html>
   <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; }
+    pre { background: #f4f4f5; padding: 1rem; overflow: auto; max-height: 50vh; }
     a { color: #0b57d0; }
     .muted { color: #666; }
+    table { border-collapse: collapse; width: 100%; margin: 1rem 0; }
+    th, td { border: 1px solid #ddd; padding: 0.5rem; text-align: left; vertical-align: top; }
+    th { background: #f6f6f6; }
+    .fail { color: #b42318; font-weight: 600; }
+    .pass { color: #027a48; font-weight: 600; }
+    section { margin: 1.5rem 0; }
   </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>
+  <p id="nav"></p>
+  <div id="content"><pre id="out">Loading\u2026</pre></div>
   <script>
-    fetch("/api/traces").then((r) => r.json()).then((data) => {
-      document.getElementById("out").textContent = JSON.stringify(data, null, 2);
-    }).catch((err) => {
+    const params = new URLSearchParams(location.search);
+    const mode = params.get("mode") || "traces";
+
+    function renderSuite(data) {
+      const rows = data.cases.map((c) =>
+        '<tr><td>' + c.id + '</td><td class="' + c.status + '">' + c.status +
+        '</td><td>' + (c.message || '') + '</td><td>' + c.toolPath.join(' \u2192 ') +
+        '</td><td>' + c.observations.map((o) => o.name + ':' + o.status).join(', ') + '</td></tr>'
+      ).join('');
+      const failed = data.cases.filter((c) => c.status !== 'pass');
+      const detail = failed.map((c) => {
+        let html = '<h3>Case ' + c.id + '</h3><ul>';
+        if (c.failureDiff) html += '<li>Diff errors: ' + c.failureDiff.summary.errors + '</li>';
+        if (c.timeline) html += '<li>Timeline steps: ' + c.timeline.entries.length + '</li>';
+        html += '<li>Diagnostics: ' + c.diagnostics.map((d) => d.message).join('; ') + '</li></ul>';
+        return html;
+      }).join('');
+      return '<section><h2>Suite: ' + data.suiteName + ' (' + data.status + ')</h2>' +
+        '<p>Passed ' + data.summary.passed + ', failed ' + data.summary.failed + '</p>' +
+        '<table><thead><tr><th>Case</th><th>Status</th><th>Message</th><th>Tool path</th><th>Observations</th></tr></thead><tbody>' +
+        rows + '</tbody></table>' +
+        '<section><h2>Failure detail</h2>' + (detail || '<p class="pass">No failures</p>') + '</section>' +
+        '<section><h2>CI artifacts</h2><p>' + (data.ciArtifactsDir || 'n/a') + '</p></section>' +
+        '<section><h2>Bundle export</h2><p>' + data.bundleExportHint + '</p></section>';
+    }
+
+    async function load() {
+      const nav = document.getElementById("nav");
+      const out = document.getElementById("out");
+      const content = document.getElementById("content");
+      if (mode === "suite") {
+        nav.innerHTML = '<a href="/api/suite">/api/suite</a>';
+        const data = await fetch("/api/suite").then((r) => r.json());
+        content.innerHTML = renderSuite(data);
+        return;
+      }
+      if (mode === "workspace") {
+        nav.innerHTML = '<a href="/api/workspace">/api/workspace</a>';
+        const data = await fetch("/api/workspace").then((r) => r.json());
+        content.innerHTML = '<section><h2>Workspace: ' + (data.project || 'workspace') + '</h2>' +
+          '<p>Runs: ' + data.runs.length + '</p><pre>' + JSON.stringify(data, null, 2) + '</pre></section>';
+        return;
+      }
+      nav.innerHTML = '<a href="/api/traces">/api/traces</a> \xB7 <a href="/api/sessions">/api/sessions</a>';
+      const data = await fetch("/api/traces").then((r) => r.json());
+      out.textContent = JSON.stringify(data, null, 2);
+    }
+    load().catch((err) => {
       document.getElementById("out").textContent = String(err);
     });
   </script>
@@ -3891,6 +4704,815 @@ var viewerIndexHtml = `<!DOCTYPE html>
 </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);
+    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,
+    status: suiteCase.status,
+    ...suiteCase.tracePath !== void 0 ? { tracePath: suiteCase.tracePath } : {},
+    ...suiteCase.runId !== void 0 ? { runId: suiteCase.runId } : {},
+    ...suiteCase.message !== void 0 ? { message: suiteCase.message } : {},
+    diagnostics: suiteCase.diagnostics,
+    toolPath: [],
+    observations: []
+  };
+  if (suiteCase.tracePath === void 0) return base;
+  try {
+    const read = await openTrace({ type: "file", path: suiteCase.tracePath });
+    const legacy = persistedInspectEventsToTraceEvents(read.events);
+    const timeline = buildRunTimeline(legacy, { focus: "all" });
+    const observations = extractOutcomesFromTraceEvents(legacy);
+    const toolPath = timeline.entries.filter((entry) => entry.type === "tool").map((entry) => entry.name);
+    const detail = {
+      ...base,
+      timeline,
+      toolPath,
+      observations
+    };
+    if (baselineTracePath !== void 0 && suiteCase.status !== "pass") {
+      try {
+        const baselineRead = await openTrace({ type: "file", path: baselineTracePath });
+        const diff = diffRuns(
+          manualTraceEventsToComparableRun(
+            persistedInspectEventsToTraceEvents(baselineRead.events)
+          ),
+          manualTraceEventsToComparableRun(legacy)
+        );
+        detail.failureDiff = {
+          summary: diff.summary,
+          differences: diff.differences.slice(0, 20).map((item) => ({
+            kind: item.kind,
+            message: item.message
+          }))
+        };
+      } catch {
+      }
+    }
+    return detail;
+  } catch {
+    return base;
+  }
+}
+async function loadSuiteViewerData(options) {
+  const result = await runSuite({
+    configPath: options.suiteConfigPath,
+    cwd: options.cwd
+  });
+  const baselineCase = result.cases.find((item) => item.status === "pass");
+  const baselinePath = baselineCase?.tracePath;
+  const cases = [];
+  for (const suiteCase of result.cases) {
+    cases.push(await enrichCase(suiteCase, baselinePath));
+  }
+  const artifactsDir = path13.join(path13.dirname(result.configPath), ".agent-inspect/suite-runs");
+  return {
+    suiteName: result.suiteName,
+    configPath: result.configPath,
+    tracesDir: result.tracesDir,
+    ok: result.ok,
+    status: result.status,
+    summary: result.summary,
+    cases,
+    ciArtifactsDir: artifactsDir,
+    bundleExportHint: "Export a share-safe bundle with: npx agent-inspect bundle <runId> --profile share"
+  };
+}
+
+// packages/core/src/workspace/types.ts
+var WORKSPACE_SCHEMA_VERSION = "1.0";
+var WORKSPACE_DIR_NAME = ".agent-inspect";
+var WORKSPACE_MANIFEST_FILENAME = "workspace.json";
+
+// packages/core/src/workspace/manifest.ts
+var REDACTION_PROFILES = [
+  "local",
+  "share",
+  "strict"
+];
+var INDEX_TYPES = ["none", "sqlite", "custom"];
+var MAX_WORKSPACE_MANIFEST_BYTES = 64 * 1024;
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSafeRelativeWorkspacePath(p) {
+  if (typeof p !== "string") return false;
+  const trimmed = p.trim();
+  if (trimmed === "") return false;
+  if (trimmed.startsWith("/") || trimmed.startsWith("\\")) return false;
+  if (/^[a-zA-Z]:/.test(trimmed)) return false;
+  const segments = trimmed.split(/[/\\]+/);
+  return !segments.some((seg) => seg === "..");
+}
+function validateDirField(value, field, errors) {
+  if (typeof value !== "string" || value.trim() === "") {
+    errors.push(`${field} must be a non-empty string`);
+    return;
+  }
+  if (!isSafeRelativeWorkspacePath(value)) {
+    errors.push(
+      `${field} must be a relative path inside the workspace (no absolute paths or ".." traversal)`
+    );
+  }
+}
+function validateIndex(value, errors) {
+  if (!isPlainObject(value)) {
+    errors.push("index must be an object");
+    return void 0;
+  }
+  if (typeof value.enabled !== "boolean") {
+    errors.push("index.enabled must be a boolean");
+  }
+  if (!INDEX_TYPES.includes(value.type)) {
+    errors.push(`index.type must be one of: ${INDEX_TYPES.join(", ")}`);
+  }
+  if (value.path !== void 0 && !isSafeRelativeWorkspacePath(value.path)) {
+    errors.push(
+      'index.path must be a relative path inside the workspace (no absolute paths or ".." traversal)'
+    );
+  }
+  if (errors.length > 0) return void 0;
+  return {
+    enabled: value.enabled,
+    type: value.type,
+    ...value.path !== void 0 ? { path: value.path } : {}
+  };
+}
+function validateWorkspaceManifest(input) {
+  const errors = [];
+  const warnings = [];
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["manifest must be an object"], warnings };
+  }
+  if (input.schemaVersion !== WORKSPACE_SCHEMA_VERSION) {
+    errors.push(
+      `schemaVersion must be "${WORKSPACE_SCHEMA_VERSION}" (received ${JSON.stringify(
+        input.schemaVersion
+      )})`
+    );
+  }
+  if (typeof input.project !== "string" || input.project.trim() === "") {
+    errors.push("project must be a non-empty string");
+  }
+  if (typeof input.createdAt !== "string" || input.createdAt.trim() === "") {
+    errors.push("createdAt must be a non-empty ISO-8601 string");
+  } else if (Number.isNaN(Date.parse(input.createdAt))) {
+    errors.push("createdAt must be a valid ISO-8601 date string");
+  }
+  if (!Array.isArray(input.traceDirs) || input.traceDirs.length === 0) {
+    errors.push("traceDirs must be a non-empty array");
+  } else {
+    input.traceDirs.forEach((dir, i) => {
+      if (typeof dir !== "string" || dir.trim() === "") {
+        errors.push(`traceDirs[${i}] must be a non-empty string`);
+      } else if (!isSafeRelativeWorkspacePath(dir)) {
+        errors.push(
+          `traceDirs[${i}] must be a relative path inside the workspace (no absolute paths or ".." traversal)`
+        );
+      }
+    });
+  }
+  validateDirField(input.reportsDir, "reportsDir", errors);
+  validateDirField(input.artifactsDir, "artifactsDir", errors);
+  validateDirField(input.bundlesDir, "bundlesDir", errors);
+  validateDirField(input.notesDir, "notesDir", errors);
+  if (!REDACTION_PROFILES.includes(input.redactionProfile)) {
+    errors.push(`redactionProfile must be one of: ${REDACTION_PROFILES.join(", ")}`);
+  }
+  const indexErrors = [];
+  const index = validateIndex(input.index, indexErrors);
+  errors.push(...indexErrors);
+  if (index && index.type !== "none" && !index.enabled) {
+    warnings.push(`index.type is "${index.type}" but index.enabled is false`);
+  }
+  if (errors.length > 0 || index === void 0) {
+    return { ok: false, errors, warnings };
+  }
+  const manifest = {
+    schemaVersion: WORKSPACE_SCHEMA_VERSION,
+    project: input.project.trim(),
+    createdAt: input.createdAt,
+    traceDirs: input.traceDirs.map((d) => d.trim()),
+    reportsDir: input.reportsDir.trim(),
+    artifactsDir: input.artifactsDir.trim(),
+    bundlesDir: input.bundlesDir.trim(),
+    notesDir: input.notesDir.trim(),
+    redactionProfile: input.redactionProfile,
+    index
+  };
+  return { ok: true, manifest, errors, warnings };
+}
+function parseWorkspaceManifest(json) {
+  const warnings = [];
+  if (typeof json !== "string") {
+    return { ok: false, errors: ["manifest input must be a string"], warnings };
+  }
+  if (json.length > MAX_WORKSPACE_MANIFEST_BYTES) {
+    return {
+      ok: false,
+      errors: [
+        `manifest exceeds maximum size of ${MAX_WORKSPACE_MANIFEST_BYTES} bytes`
+      ],
+      warnings
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return { ok: false, errors: ["manifest is not valid JSON"], warnings };
+  }
+  return validateWorkspaceManifest(parsed);
+}
+var INDEX_DIR_NAME = "index";
+function resolveWorkspaceLocation(cwd = process.cwd()) {
+  const projectRoot = path13.resolve(cwd);
+  const workspaceDir = path13.join(projectRoot, WORKSPACE_DIR_NAME);
+  return {
+    projectRoot,
+    workspaceDir,
+    manifestPath: path13.join(workspaceDir, WORKSPACE_MANIFEST_FILENAME)
+  };
+}
+function resolveInsideWorkspace(workspaceDir, relative) {
+  const base = path13.resolve(workspaceDir);
+  const resolved = path13.resolve(base, relative);
+  const rel = path13.relative(base, resolved);
+  if (rel === "" || rel === "." || !rel.startsWith("..") && !path13.isAbsolute(rel)) {
+    return resolved;
+  }
+  throw new Error(
+    `Workspace path "${relative}" resolves outside the workspace directory`
+  );
+}
+async function pathExists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isWritable(p) {
+  try {
+    await access(p, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listJsonl(dir) {
+  try {
+    const entries = await readdir(dir);
+    return entries.filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return [];
+  }
+}
+async function countFiles(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile()).length;
+  } catch {
+    return 0;
+  }
+}
+async function readWorkspaceManifestFile(location) {
+  let raw;
+  try {
+    raw = await readFile(location.manifestPath, "utf-8");
+  } catch {
+    return { exists: false, ok: false, errors: ["workspace.json not found"], warnings: [] };
+  }
+  const parsed = parseWorkspaceManifest(raw);
+  return {
+    exists: true,
+    ok: parsed.ok,
+    ...parsed.manifest ? { manifest: parsed.manifest } : {},
+    errors: parsed.errors,
+    warnings: parsed.warnings
+  };
+}
+async function getWorkspaceStatus(location, manifest) {
+  let traceFiles = 0;
+  for (const rel of manifest.traceDirs) {
+    const abs = resolveInsideWorkspace(location.workspaceDir, rel);
+    traceFiles += (await listJsonl(abs)).length;
+  }
+  const reports = await countFiles(
+    resolveInsideWorkspace(location.workspaceDir, manifest.reportsDir)
+  );
+  const artifacts = await countFiles(
+    resolveInsideWorkspace(location.workspaceDir, manifest.artifactsDir)
+  );
+  const bundles = await countFiles(
+    resolveInsideWorkspace(location.workspaceDir, manifest.bundlesDir)
+  );
+  const notes = await countFiles(
+    resolveInsideWorkspace(location.workspaceDir, manifest.notesDir)
+  );
+  const indexPath = manifest.index.path ? resolveInsideWorkspace(location.workspaceDir, manifest.index.path) : resolveInsideWorkspace(location.workspaceDir, INDEX_DIR_NAME);
+  return {
+    project: manifest.project,
+    traceFiles,
+    reports,
+    artifacts,
+    bundles,
+    notes,
+    index: {
+      enabled: manifest.index.enabled,
+      type: manifest.index.type,
+      exists: await pathExists(indexPath)
+    }
+  };
+}
+async function doctorWorkspace(location) {
+  const checks = [];
+  const manifestResult = await readWorkspaceManifestFile(location);
+  if (!manifestResult.exists) {
+    checks.push({
+      id: "manifest",
+      status: "fail",
+      message: "workspace.json not found (run `agent-inspect workspace init`)"
+    });
+    return { ok: false, checks };
+  }
+  if (!manifestResult.ok || !manifestResult.manifest) {
+    checks.push({
+      id: "manifest",
+      status: "fail",
+      message: `workspace.json is invalid: ${manifestResult.errors.join("; ")}`
+    });
+    return { ok: false, checks };
+  }
+  const manifest = manifestResult.manifest;
+  checks.push({ id: "manifest", status: "pass", message: "workspace.json is valid" });
+  for (const warning of manifestResult.warnings) {
+    checks.push({ id: "manifest-warning", status: "warn", message: warning });
+  }
+  const dirFields = [
+    ...manifest.traceDirs.filter((d) => d !== ".").map((d, i) => [`traceDir[${i}]`, d]),
+    ["reportsDir", manifest.reportsDir],
+    ["artifactsDir", manifest.artifactsDir],
+    ["bundlesDir", manifest.bundlesDir],
+    ["notesDir", manifest.notesDir]
+  ];
+  for (const [id, rel] of dirFields) {
+    let abs;
+    try {
+      abs = resolveInsideWorkspace(location.workspaceDir, rel);
+    } catch (error) {
+      checks.push({
+        id,
+        status: "fail",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    if (!await pathExists(abs)) {
+      checks.push({ id, status: "warn", message: `${rel}/ does not exist yet` });
+    } else if (!await isWritable(abs)) {
+      checks.push({ id, status: "fail", message: `${rel}/ is not writable` });
+    } else {
+      checks.push({ id, status: "pass", message: `${rel}/ is present and writable` });
+    }
+  }
+  let newestTraceMtime = 0;
+  for (const rel of manifest.traceDirs) {
+    const abs = resolveInsideWorkspace(location.workspaceDir, rel);
+    for (const file of await listJsonl(abs)) {
+      try {
+        const s = await stat(path13.join(abs, file));
+        newestTraceMtime = Math.max(newestTraceMtime, s.mtimeMs);
+      } catch {
+        checks.push({ id: "trace-readability", status: "warn", message: `cannot stat ${rel}/${file}` });
+      }
+    }
+  }
+  if (manifest.index.enabled) {
+    const indexPath = manifest.index.path ? resolveInsideWorkspace(location.workspaceDir, manifest.index.path) : resolveInsideWorkspace(location.workspaceDir, INDEX_DIR_NAME);
+    if (!await pathExists(indexPath)) {
+      checks.push({ id: "index", status: "warn", message: "index enabled but not built" });
+    } else {
+      try {
+        const s = await stat(indexPath);
+        if (newestTraceMtime > s.mtimeMs) {
+          checks.push({ id: "index", status: "warn", message: "index is stale (traces are newer)" });
+        } else {
+          checks.push({ id: "index", status: "pass", message: "index is present" });
+        }
+      } catch {
+        checks.push({ id: "index", status: "warn", message: "cannot stat index" });
+      }
+    }
+  }
+  const ok = !checks.some((c) => c.status === "fail");
+  return { ok, checks };
+}
+
+// packages/viewer/src/workspace-data.ts
+async function loadWorkspaceViewerData(options) {
+  const cwd = path13.resolve(options.cwd ?? process.cwd());
+  const location = resolveWorkspaceLocation(cwd);
+  const manifestRead = await readWorkspaceManifestFile(location);
+  if (!manifestRead.ok || manifestRead.manifest === void 0) {
+    throw new Error(
+      manifestRead.errors.join("; ") || "workspace.json not found (run workspace init)"
+    );
+  }
+  const status = await getWorkspaceStatus(location, manifestRead.manifest);
+  const doctor = await doctorWorkspace(location);
+  const runs = [];
+  for (const rel of manifestRead.manifest.traceDirs) {
+    const traceDir = resolveTraceDir({
+      dir: path13.join(location.workspaceDir, rel)
+    });
+    const td = new TraceDirectory({ dir: traceDir });
+    const files = await td.list();
+    const metas = await loadTraceMetadataList(
+      traceDir,
+      files,
+      (fileName) => td.getPath(fileName)
+    );
+    for (const meta of metas) {
+      runs.push({
+        runId: meta.runId,
+        ...meta.name !== void 0 ? { name: meta.name } : {},
+        status: meta.status,
+        file: path13.basename(meta.filePath)
+      });
+    }
+  }
+  return {
+    workspaceDir: location.workspaceDir,
+    ...status.project !== void 0 ? { project: status.project } : {},
+    status,
+    doctor,
+    runs,
+    bundleDirs: [
+      path13.join(location.workspaceDir, manifestRead.manifest.bundlesDir),
+      path13.join(location.workspaceDir, manifestRead.manifest.artifactsDir)
+    ]
+  };
+}
+
 // packages/viewer/src/server.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 7337;
@@ -3926,6 +5548,7 @@ function createViewerServer(options = {}) {
   const host = options.host ?? DEFAULT_HOST;
   const port = options.port ?? DEFAULT_PORT;
   const maxEvents = options.maxEvents ?? DEFAULT_MAX_EVENTS;
+  const mode = options.mode ?? "traces";
   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."
@@ -3947,9 +5570,21 @@ function createViewerServer(options = {}) {
         return sendJson(res, 200, {
           ok: true,
           readOnly: true,
-          traceDir: path11.resolve(traceDir)
+          mode,
+          traceDir: path13.resolve(traceDir)
         });
       }
+      if (pathname === "/api/suite" && mode === "suite") {
+        const data = await loadSuiteViewerData({
+          suiteConfigPath: options.suiteConfigPath,
+          cwd: options.cwd
+        });
+        return sendJson(res, 200, data);
+      }
+      if (pathname === "/api/workspace" && mode === "workspace") {
+        const data = await loadWorkspaceViewerData({ cwd: options.cwd });
+        return sendJson(res, 200, data);
+      }
       const td = new TraceDirectory({ dir: traceDir });
       if (pathname === "/api/traces") {
         const files = await td.list();
@@ -3965,7 +5600,7 @@ function createViewerServer(options = {}) {
             runId: meta.runId,
             name: meta.name,
             status: meta.status,
-            file: path11.basename(meta.filePath),
+            file: path13.basename(meta.filePath),
             startedAt: meta.startedAt,
             durationMs: meta.durationMs
           }))
@@ -4071,22 +5706,25 @@ function startViewerServer(options = {}) {
   const host = options.host ?? DEFAULT_HOST;
   const port = options.port ?? DEFAULT_PORT;
   const traceDir = resolveTraceDir({ dir: options.traceDir });
+  const mode = options.mode ?? "traces";
   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;
+      const modeQuery = mode === "traces" ? "" : `?mode=${encodeURIComponent(mode)}`;
       resolve({
         host,
         port: resolvedPort,
-        traceDir: path11.resolve(traceDir),
-        url: `http://${host}:${resolvedPort}`
+        traceDir: path13.resolve(traceDir),
+        url: `http://${host}:${resolvedPort}/${modeQuery}`,
+        mode
       });
     });
   });
 }
 
-export { createViewerServer, startViewerServer, viewerIndexHtml };
+export { createViewerServer, loadSuiteViewerData, loadWorkspaceViewerData, startViewerServer, viewerIndexHtml };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map