agent-inspect 6.9.0 → 6.10.0

package/packages/core/dist/advanced.mjs

@@ -2,10 +2,11 @@ import { runTraceChecks, createRunStatusRule, createToolUsageRule, createRunDura
 export { MAX_TERMINAL_DEPTH, MAX_TERMINAL_NAME_LENGTH, TERMINAL_INDENT, TraceDirectory, createInspector, createInspectorRuntime, formatTerminalName, getCurrentContext, getCurrentCorrelationMetadata, getCurrentDepth, getCurrentRunId, getCurrentRunName, getCurrentStepId, getIndent, getParentStepId, getTraceDirFromContext, getTraceSafetyFromContext, hasActiveContext, isAgentInspectEnabled, isSilentContext, maybeInspectRun, printError, printFailedAt, printRunComplete, printRunStart, printStepComplete, printStepStart, renderErrorLine, renderRunSummary, renderStepLine, resolveTraceDir, runWithContext, runWithStepContext } from './chunk-ZWA5RWMV.mjs';
 import { filterTraces, extractMetadata, buildRunSummary } from './chunk-KDDU2R5P.mjs';
 export { buildRunSummary, buildRunTimeline, buildRunWhatSummary, buildTraceStats, extractMetadata, filterTraces, renderRunWhat, renderTimeline, renderTraceStats } from './chunk-KDDU2R5P.mjs';
-import { parseObservationFilter, extractOutcomesFromTraceEvents, extractOutcomesFromPersistedEvents } from './chunk-VFO76UH3.mjs';
+import { parseObservationFilter, extractOutcomesFromTraceEvents, summarizeObservedOutcomes, extractOutcomesFromPersistedEvents, renderObservedOutcomesHtml } from './chunk-VFO76UH3.mjs';
 export { extractOutcomesFromPersistedEvents, extractOutcomesFromTraceEvents } from './chunk-VFO76UH3.mjs';
+import { diffTraceEvents, renderRunDiff } from './chunk-F7STQ5JF.mjs';
 import './chunk-BT7CATSD.mjs';
-import { escapeHtml } from './chunk-CAWPF22J.mjs';
+import { escapeHtml, flattenTree } from './chunk-CAWPF22J.mjs';
 import { resolveRedactionProfile, readTraceEventsFromFile } from './chunk-ULCGIRTC.mjs';
 export { DEFAULT_MAX_EVENT_BYTES, DEFAULT_MAX_METADATA_VALUE_LENGTH, DEFAULT_MAX_PREVIEW_LENGTH, getRunIdFromTraceFileName, initializeTraceFile, listTraceFiles, prepareMetadataForDisk, prepareTraceEventForDisk, readTraceEvents, readTraceFile, resolveRedactionProfile, resolveTraceSafetyOptions, serializeEvent, validateEvent, writeTraceEvent } from './chunk-ULCGIRTC.mjs';
 import { Redactor } from './chunk-VU6O5QAH.mjs';
@@ -15,12 +16,13 @@ import './chunk-S4YWKV4G.mjs';
 import './chunk-T5MASTIW.mjs';
 import { parseDuration, isTraceEvent, getTraceFilePath } from './chunk-WRE4CNPF.mjs';
 export { DEFAULT_TRACE_DIR_NAME, FALLBACK_TRACE_DIR, MAX_NAME_LENGTH, RUNS_DIR_NAME, createRunId, createStepId, ensureTraceDir, formatDuration, formatError, formatTimestamp, getDefaultTraceDir, getTraceFilePath, isStepStatus, isStepType, isTraceEvent, parseDuration, parseTraceJsonl, truncateName, unknownTraceFormatMessage, warn } from './chunk-WRE4CNPF.mjs';
-import './chunk-P366CCL2.mjs';
+import { persistedInspectEventsToTraceEvents } from './chunk-P366CCL2.mjs';
 import './chunk-7TGZLWEE.mjs';
 import { createReadStream } from 'fs';
 import { createInterface } from 'readline';
 import path from 'path';
-import { access, readFile } from 'fs/promises';
+import { createHash } from 'crypto';
+import { stat, readFile, access, readdir } from 'fs/promises';
 import { pathToFileURL } from 'url';
 
 // packages/core/src/explain.ts
@@ -1111,12 +1113,12 @@ function buildCriticalPath(runs, handoffs) {
     handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.from)
   );
   const ordered = [...runs].sort(compareRuns);
-  const path7 = [];
+  const path9 = [];
   const visited = /* @__PURE__ */ new Set();
   const pushRun = (run, confidence, source) => {
     if (visited.has(run.runId)) return;
     visited.add(run.runId);
-    path7.push({
+    path9.push({
       runId: run.runId,
       name: run.name,
       startedAt: run.startedAt,
@@ -1141,7 +1143,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 path7;
+  return path9;
 }
 function metaRunIdMatches(run, token, runById) {
   const meta = extractSessionWorkflowMetadata(run.metadata);
@@ -1451,13 +1453,13 @@ function assertBundlePathContained(outputDir, relativePath) {
   }
   return resolved;
 }
-function normalizeBundleOutputPath(out) {
+function normalizeBundleOutputPath(out, options) {
   const trimmed = out.trim();
   if (trimmed === "") {
     throw new Error("--out requires a non-empty path.");
   }
   const resolved = path.resolve(trimmed);
-  if (resolved.toLowerCase().endsWith(".zip")) {
+  if (options?.preserveZipExtension !== true && resolved.toLowerCase().endsWith(".zip")) {
     return resolved.slice(0, -4);
   }
   return resolved;
@@ -1468,6 +1470,1157 @@ function defaultBundleOutputPath(runIds) {
   return path.resolve(`agent-inspect-bundle-${label}-${stamp}`);
 }
 
+// packages/core/src/evidence/types.ts
+var EVIDENCE_FORMAT_VERSION = "1.0";
+var EVIDENCE_ASSESSMENT_NOTE = "Best-effort local safety verification only; not a compliance certification.";
+var EVIDENCE_MANIFEST_FILENAME = "evidence.json";
+var SHA256_RE = /^[a-f0-9]{64}$/i;
+function sha256Hex(data) {
+  const hash = createHash("sha256");
+  if (typeof data === "string") {
+    hash.update(data, "utf8");
+  } else {
+    hash.update(data);
+  }
+  return hash.digest("hex");
+}
+function isSha256Hex(value) {
+  return SHA256_RE.test(value);
+}
+function sha256Equals(expected, actual) {
+  if (!isSha256Hex(expected) || !isSha256Hex(actual)) {
+    return false;
+  }
+  const a = expected.toLowerCase();
+  const b = actual.toLowerCase();
+  if (a.length !== b.length) return false;
+  let mismatch = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return mismatch === 0;
+}
+function assertEvidenceRelativePath(relativePath) {
+  if (typeof relativePath !== "string" || relativePath.trim() === "") {
+    throw new Error("Evidence file path must be a non-empty relative path.");
+  }
+  const trimmed = relativePath.trim().replaceAll("\\", "/");
+  if (path.isAbsolute(trimmed) || trimmed.startsWith("/")) {
+    throw new Error(`Evidence file path must be relative: ${relativePath}`);
+  }
+  const parts = trimmed.split("/").filter((part) => part !== "");
+  if (parts.length === 0) {
+    throw new Error(`Evidence file path must be relative: ${relativePath}`);
+  }
+  for (const part of parts) {
+    if (part === "." || part === "..") {
+      throw new Error(`Evidence file path must not contain "." or "..": ${relativePath}`);
+    }
+  }
+  return parts.join("/");
+}
+
+// packages/core/src/evidence/manifest.ts
+function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (value === null || typeof value !== "object") return value;
+  const record = value;
+  return Object.fromEntries(
+    Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => [key, stable(record[key])])
+  );
+}
+function serializeEvidenceManifest(manifest) {
+  return `${JSON.stringify(stable(manifest), null, 2)}
+`;
+}
+function inferEvidenceFileRole(relativePath) {
+  const normalized = assertEvidenceRelativePath(relativePath);
+  const base = normalized.includes("/") ? normalized.slice(normalized.lastIndexOf("/") + 1) : normalized;
+  if (base === "evidence.html" || base === "trace.html" || base.endsWith(".html")) {
+    return "report";
+  }
+  if (base === "trace.jsonl" || base.endsWith(".jsonl")) {
+    return "redacted-trace";
+  }
+  if (base === "check-results.json") {
+    return "checks";
+  }
+  if (base === "redaction-report.json") {
+    return "redaction-report";
+  }
+  if (base === "summary.md") {
+    return "summary";
+  }
+  return "other";
+}
+function buildEvidenceFileEntries(files) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const relativePath = assertEvidenceRelativePath(file.path);
+    if (relativePath === EVIDENCE_MANIFEST_FILENAME) {
+      throw new Error(
+        `Do not include ${EVIDENCE_MANIFEST_FILENAME} in packaged file hashes (self-hash is undefined).`
+      );
+    }
+    if (byPath.has(relativePath)) {
+      throw new Error(`Duplicate evidence file path: ${relativePath}`);
+    }
+    byPath.set(relativePath, {
+      path: relativePath,
+      sha256: sha256Hex(file.content),
+      role: file.role ?? inferEvidenceFileRole(relativePath)
+    });
+  }
+  return [...byPath.values()].sort((a, b) => a.path.localeCompare(b.path));
+}
+function buildEvidenceManifest(parts) {
+  const runIds = [...parts.runIds];
+  if (runIds.length === 0) {
+    throw new Error("Evidence manifest requires at least one run id.");
+  }
+  for (const item of parts.sourceHashes) {
+    if (!runIds.includes(item.runId)) {
+      throw new Error(`sourceHashes runId "${item.runId}" is not listed in source.runIds.`);
+    }
+    if (item.algorithm !== "sha256") {
+      throw new Error(`Unsupported source hash algorithm: ${item.algorithm}`);
+    }
+  }
+  const assessment = {
+    status: parts.assessmentStatus,
+    note: parts.note ?? EVIDENCE_ASSESSMENT_NOTE
+  };
+  if (parts.sourceStatus !== void 0) {
+    assessment.sourceStatus = parts.sourceStatus;
+  }
+  return {
+    evidenceFormatVersion: EVIDENCE_FORMAT_VERSION,
+    generator: {
+      name: parts.generatorName ?? "agent-inspect",
+      version: parts.generatorVersion
+    },
+    createdAt: parts.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    source: {
+      runIds,
+      traceSchemaVersions: [...parts.traceSchemaVersions].sort((a, b) => a.localeCompare(b)),
+      sourceHashes: [...parts.sourceHashes].sort((a, b) => a.runId.localeCompare(b.runId))
+    },
+    policy: {
+      redactionProfile: parts.redactionProfile,
+      verificationPolicy: parts.verificationPolicy ?? parts.redactionProfile
+    },
+    assessment,
+    files: buildEvidenceFileEntries(parts.files)
+  };
+}
+function validateEvidenceManifest(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Evidence manifest must be a JSON object.");
+  }
+  const record = value;
+  if (record.evidenceFormatVersion !== EVIDENCE_FORMAT_VERSION) {
+    throw new Error(
+      `Unsupported evidenceFormatVersion: ${String(record.evidenceFormatVersion)}`
+    );
+  }
+  const generator = record.generator;
+  if (generator === null || typeof generator !== "object" || Array.isArray(generator) || typeof generator.name !== "string" || typeof generator.version !== "string") {
+    throw new Error("Evidence manifest requires generator.name and generator.version.");
+  }
+  const source = record.source;
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    throw new Error("Evidence manifest requires source.");
+  }
+  const sourceRecord = source;
+  if (!Array.isArray(sourceRecord.runIds) || sourceRecord.runIds.length === 0) {
+    throw new Error("Evidence manifest source.runIds must be a non-empty array.");
+  }
+  if (!Array.isArray(sourceRecord.traceSchemaVersions)) {
+    throw new Error("Evidence manifest source.traceSchemaVersions must be an array.");
+  }
+  if (!Array.isArray(sourceRecord.sourceHashes)) {
+    throw new Error("Evidence manifest source.sourceHashes must be an array.");
+  }
+  const policy = record.policy;
+  if (policy === null || typeof policy !== "object" || Array.isArray(policy)) {
+    throw new Error("Evidence manifest requires policy.");
+  }
+  const assessment = record.assessment;
+  if (assessment === null || typeof assessment !== "object" || Array.isArray(assessment) || typeof assessment.status !== "string") {
+    throw new Error("Evidence manifest requires assessment.status.");
+  }
+  if (!Array.isArray(record.files) || record.files.length === 0) {
+    throw new Error("Evidence manifest files must be a non-empty array.");
+  }
+  for (const file of record.files) {
+    if (file === null || typeof file !== "object" || Array.isArray(file)) {
+      throw new Error("Evidence manifest file entries must be objects.");
+    }
+    const entry = file;
+    if (typeof entry.path !== "string") {
+      throw new Error("Evidence file entry requires path.");
+    }
+    assertEvidenceRelativePath(entry.path);
+    if (typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/i.test(entry.sha256)) {
+      throw new Error(`Evidence file entry requires sha256 hex for ${entry.path}.`);
+    }
+  }
+  return value;
+}
+function parseEvidenceManifestJson(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Evidence manifest is not valid JSON: ${message}`);
+  }
+  return validateEvidenceManifest(parsed);
+}
+function collectTraceSchemaVersions(jsonl) {
+  const versions = /* @__PURE__ */ new Set();
+  for (const line of jsonl.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (typeof row.schemaVersion === "string" && row.schemaVersion.trim() !== "") {
+        versions.add(row.schemaVersion.trim());
+      }
+    } catch {
+    }
+  }
+  return [...versions].sort((a, b) => a.localeCompare(b));
+}
+
+// packages/core/src/evidence/views.ts
+function renderTreeHtml(nodes, ulClass = "tree") {
+  if (nodes.length === 0) return "";
+  const parts = [`<ul class="${ulClass}">`];
+  for (const n of nodes) {
+    const ev = n.event;
+    const status = ev.status ?? "?";
+    const dur = ev.durationMs !== void 0 && Number.isFinite(ev.durationMs) ? `${ev.durationMs}ms` : "-";
+    const errClass = ev.status === "error" ? " is-error" : "";
+    parts.push(`<li class="tree-node${errClass}">`);
+    parts.push(
+      `<span class="nm">${escapeHtml(ev.name)}</span> <span class="meta">[${escapeHtml(ev.kind)}] ${escapeHtml(status)} (${escapeHtml(dur)})</span>`
+    );
+    if (n.children.length > 0) {
+      parts.push(renderTreeHtml(n.children, "tree nested"));
+    }
+    parts.push("</li>");
+  }
+  parts.push("</ul>");
+  return parts.join("");
+}
+function buildEvidenceTreeViewHtml(trees) {
+  if (trees.length === 0) {
+    return `<p class="muted">No execution trees available.</p>`;
+  }
+  const parts = [];
+  for (const tree of trees) {
+    parts.push(`<article class="run-block">`);
+    parts.push(`<h3><code>${escapeHtml(tree.runId)}</code></h3>`);
+    if (tree.name) {
+      parts.push(`<p class="muted">Name: ${escapeHtml(tree.name)}</p>`);
+    }
+    parts.push(
+      `<p>Status: <strong>${escapeHtml(String(tree.status ?? "unknown"))}</strong>${tree.durationMs !== void 0 ? ` \xB7 ${escapeHtml(String(tree.durationMs))}ms` : ""}</p>`
+    );
+    parts.push(
+      tree.children.length > 0 ? renderTreeHtml(tree.children) : `<p class="muted">No steps recorded.</p>`
+    );
+    parts.push(`</article>`);
+  }
+  return parts.join("\n");
+}
+function timelineRows(tree) {
+  const flat = flattenTree(tree);
+  const origin = tree.startedAt ?? flat.reduce((min, n) => {
+    const t = n.event.timestamp;
+    if (!Number.isFinite(t)) return min;
+    return min === void 0 ? t : Math.min(min, t);
+  }, void 0) ?? 0;
+  return flat.filter((n) => n.event.kind !== "RUN").map((n) => {
+    const started = Number.isFinite(n.event.timestamp) ? n.event.timestamp : origin;
+    const durationMs = n.event.durationMs !== void 0 && Number.isFinite(n.event.durationMs) ? Math.max(0, n.event.durationMs) : 0;
+    return {
+      name: n.event.name,
+      kind: n.event.kind,
+      status: n.event.status ?? "?",
+      offsetMs: Math.max(0, started - origin),
+      durationMs,
+      isError: n.event.status === "error"
+    };
+  }).sort((a, b) => a.offsetMs - b.offsetMs || a.name.localeCompare(b.name));
+}
+function buildEvidenceTimelineViewHtml(trees) {
+  if (trees.length === 0) {
+    return `<p class="muted">No timeline data available.</p>`;
+  }
+  const parts = [];
+  for (const tree of trees) {
+    const rows = timelineRows(tree);
+    const maxEnd = rows.reduce(
+      (max, row) => Math.max(max, row.offsetMs + Math.max(row.durationMs, 1)),
+      1
+    );
+    parts.push(`<article class="run-block">`);
+    parts.push(`<h3><code>${escapeHtml(tree.runId)}</code></h3>`);
+    if (rows.length === 0) {
+      parts.push(`<p class="muted">No step timings recorded.</p>`);
+    } else {
+      parts.push(`<div class="waterfall" role="list">`);
+      for (const row of rows) {
+        const left = row.offsetMs / maxEnd * 100;
+        const width = Math.max(0.8, Math.max(row.durationMs, 1) / maxEnd * 100);
+        const err = row.isError ? " is-error" : "";
+        parts.push(
+          `<div class="wf-row${err}" role="listitem"><div class="wf-label"><span class="nm">${escapeHtml(row.name)}</span> <span class="meta">[${escapeHtml(row.kind)}] ${escapeHtml(row.status)} \xB7 ${escapeHtml(String(row.durationMs))}ms @+${escapeHtml(String(row.offsetMs))}ms</span></div><div class="wf-track"><span class="wf-bar" style="left:${left.toFixed(2)}%;width:${width.toFixed(2)}%"></span></div></div>`
+        );
+      }
+      parts.push(`</div>`);
+    }
+    parts.push(`</article>`);
+  }
+  return parts.join("\n");
+}
+function findNodeByEventId(nodes, eventId) {
+  for (const node of nodes) {
+    if (node.event.eventId === eventId) return node;
+    const child = findNodeByEventId(node.children, eventId);
+    if (child) return child;
+  }
+  return void 0;
+}
+function buildAncestorChain(tree, failure) {
+  const chain = [failure];
+  let parentId = failure.event.parentId;
+  const guard = /* @__PURE__ */ new Set([failure.event.eventId]);
+  while (parentId && !guard.has(parentId)) {
+    guard.add(parentId);
+    const parent = findNodeByEventId(tree.children, parentId);
+    if (!parent) break;
+    chain.unshift(parent);
+    parentId = parent.event.parentId;
+  }
+  return chain;
+}
+function buildEvidenceCausalFailureViewHtml(trees) {
+  if (trees.length === 0) {
+    return `<p class="muted">No runs available for causal analysis.</p>`;
+  }
+  const parts = [];
+  for (const tree of trees) {
+    parts.push(`<article class="run-block">`);
+    parts.push(`<h3><code>${escapeHtml(tree.runId)}</code></h3>`);
+    const errors = flattenTree(tree).filter((n) => n.event.status === "error" || n.event.kind === "ERROR").sort((a, b) => a.event.timestamp - b.event.timestamp);
+    if (errors.length === 0) {
+      parts.push(
+        `<p class="muted">No error-status events found. Run status: <strong>${escapeHtml(String(tree.status ?? "unknown"))}</strong>.</p>`
+      );
+      parts.push(`</article>`);
+      continue;
+    }
+    const first = errors[0];
+    const chain = buildAncestorChain(tree, first);
+    parts.push(`<p>First error by timestamp:</p>`);
+    parts.push(`<ol class="causal-chain">`);
+    for (const node of chain) {
+      const isTip = node.event.eventId === first.event.eventId;
+      const msg = typeof node.event.attributes?.message === "string" ? node.event.attributes.message : typeof node.event.attributes?.error === "string" ? node.event.attributes.error : void 0;
+      parts.push(
+        `<li class="${isTip ? "causal-tip" : ""}"><span class="nm">${escapeHtml(node.event.name)}</span> <span class="meta">[${escapeHtml(node.event.kind)}] ${escapeHtml(node.event.status ?? "?")} \xB7 ${escapeHtml(node.event.eventId)}</span>${msg ? `<div class="causal-msg">${escapeHtml(msg.slice(0, 400))}</div>` : ""}</li>`
+      );
+    }
+    parts.push(`</ol>`);
+    if (errors.length > 1) {
+      parts.push(
+        `<p class="muted">${escapeHtml(String(errors.length - 1))} additional error event(s) not shown in the primary chain.</p>`
+      );
+    }
+    parts.push(`</article>`);
+  }
+  return parts.join("\n");
+}
+var EVIDENCE_VIEW_CSS = `
+ul.tree{list-style:none;padding-left:1rem;margin:.5rem 0}
+ul.tree.nested{padding-left:1.25rem;border-left:1px solid var(--line);margin:.25rem 0}
+.tree-node.is-error .nm,.wf-row.is-error .nm,.causal-tip .nm{color:var(--unsafe)}
+.waterfall{display:flex;flex-direction:column;gap:.45rem;max-width:52rem}
+.wf-row{display:grid;grid-template-columns:minmax(10rem,18rem) 1fr;gap:.6rem;align-items:center}
+.wf-track{position:relative;height:.7rem;background:#e8e8e4;border-radius:.25rem;overflow:hidden}
+.wf-bar{position:absolute;top:0;bottom:0;background:var(--accent);border-radius:.25rem}
+.wf-row.is-error .wf-bar{background:var(--unsafe)}
+.causal-chain{max-width:44rem}
+.causal-msg{margin:.25rem 0 0;color:var(--muted);font-size:.92rem}
+.run-block{margin:0 0 1.25rem;padding-bottom:1rem;border-bottom:1px solid var(--line)}
+.run-block:last-child{border-bottom:0}
+@media (max-width:720px){
+  .wf-row{grid-template-columns:1fr}
+}
+`.trim();
+
+// packages/core/src/evidence/html-shell.ts
+var EVIDENCE_HTML_FILENAME = "evidence.html";
+var EVIDENCE_HTML_NOTE = "Generated locally by AgentInspect. Share-checked evidence for review \u2014 not a compliance or security certification.";
+var EVIDENCE_VIEW_IDS = [
+  "summary",
+  "tree",
+  "timeline",
+  "causal",
+  "tools-llm",
+  "outcomes",
+  "contracts",
+  "circuit",
+  "diff",
+  "safety",
+  "provenance"
+];
+function statusClass(status) {
+  if (status === "SAFE") return "st-safe";
+  if (status === "SAFE WITH WARNINGS") return "st-warn";
+  if (status === "UNSAFE") return "st-unsafe";
+  return "st-unknown";
+}
+function viewLabel(id) {
+  switch (id) {
+    case "summary":
+      return "Summary";
+    case "tree":
+      return "Tree";
+    case "timeline":
+      return "Timeline";
+    case "causal":
+      return "Causal failure";
+    case "tools-llm":
+      return "Tools / LLM";
+    case "outcomes":
+      return "Outcomes";
+    case "contracts":
+      return "Contracts / checks";
+    case "circuit":
+      return "Circuit / guardrails";
+    case "diff":
+      return "Diff";
+    case "safety":
+      return "Safety / redaction";
+    case "provenance":
+      return "Provenance";
+    default: {
+      const _exhaustive = id;
+      return _exhaustive;
+    }
+  }
+}
+function encodeEmbeddedEvidenceJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
+}
+function buildEmbeddedPayload(input) {
+  return {
+    evidenceFormatVersion: input.evidenceFormatVersion ?? "1.0",
+    generator: {
+      name: input.generatorName,
+      version: input.generatorVersion
+    },
+    createdAt: input.createdAt,
+    runIds: [...input.runIds],
+    assessment: {
+      status: input.assessmentStatus,
+      ...input.sourceStatus !== void 0 ? { sourceStatus: input.sourceStatus } : {}
+    },
+    policy: {
+      redactionProfile: input.redactionProfile,
+      verificationPolicy: input.verificationPolicy
+    },
+    checkSummary: input.checkSummary
+  };
+}
+function buildEvidenceHtmlShell(input) {
+  if (input.runIds.length === 0) {
+    throw new Error("Evidence HTML shell requires at least one run id.");
+  }
+  const maxChars = input.maxEmbeddedJsonChars ?? 64 * 1024;
+  let embedded = encodeEmbeddedEvidenceJson(buildEmbeddedPayload(input));
+  if (embedded.length > maxChars) {
+    embedded = encodeEmbeddedEvidenceJson({
+      truncated: true,
+      evidenceFormatVersion: input.evidenceFormatVersion ?? "1.0",
+      runIds: [...input.runIds],
+      assessment: { status: input.assessmentStatus },
+      note: "Embedded payload truncated to bound; open evidence.json / trace files for full detail."
+    });
+  }
+  const title = escapeHtml(input.title ?? "AgentInspect evidence");
+  const runList = input.runIds.map((id) => `<li><code>${escapeHtml(id)}</code></li>`).join("");
+  const summaryBody = input.summaryText !== void 0 && input.summaryText.trim() !== "" ? `<pre class="summary-md">${escapeHtml(input.summaryText)}</pre>` : `<p class="muted">Open <code>summary.md</code> in this bundle for the full text summary.</p>`;
+  const checkRows = input.checkSummary?.runs.map(
+    (run) => `<tr><td><code>${escapeHtml(run.runId)}</code></td><td class="${statusClass(run.status)}">${escapeHtml(run.status)}</td><td>${run.errors}</td><td>${run.warnings}</td><td>${run.findings}</td></tr>`
+  ).join("") ?? "";
+  const nav = EVIDENCE_VIEW_IDS.map(
+    (id) => `<a class="nav-link" href="#view-${id}" data-view="${id}">${escapeHtml(viewLabel(id))}</a>`
+  ).join("\n");
+  const stubPanels = EVIDENCE_VIEW_IDS.filter((id) => id !== "summary").map((id) => {
+    const body = input.viewBodies?.[id];
+    if (body !== void 0 && body.trim() !== "") {
+      return `  <section id="view-${id}" class="panel" hidden>
+    <h2>${escapeHtml(viewLabel(id))}</h2>
+    ${body}
+  </section>`;
+    }
+    return `  <section id="view-${id}" class="panel" hidden>
+    <h2>${escapeHtml(viewLabel(id))}</h2>
+    <p class="muted">This view will be filled in a later AgentInspect 6.10 release. The shell is offline-ready.</p>
+  </section>`;
+  }).join("\n");
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; img-src data:; base-uri 'none'; form-action 'none'; frame-ancestors 'none'"/>
+<meta name="referrer" content="no-referrer"/>
+<title>${title}</title>
+<style>
+:root{--bg:#f7f7f5;--fg:#1a1a1a;--muted:#5c5c5c;--line:#d8d8d4;--accent:#0b5fff;--safe:#0a7a3e;--warn:#9a6700;--unsafe:#b42318;--unknown:#5c5c5c}
+*{box-sizing:border-box}
+body{margin:0;font-family:ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif;background:var(--bg);color:var(--fg);line-height:1.5}
+a{color:var(--accent)}
+header{padding:1.25rem 1.5rem;border-bottom:1px solid var(--line);background:#fff}
+header h1{margin:0 0 .35rem;font-size:1.35rem}
+.note{margin:0;color:var(--muted);font-size:.92rem;max-width:52rem}
+.layout{display:grid;grid-template-columns:14rem 1fr;min-height:70vh}
+nav{padding:1rem;border-right:1px solid var(--line);background:#fff}
+nav .nav-link{display:block;padding:.4rem .55rem;margin:0 0 .2rem;border-radius:.35rem;text-decoration:none;color:inherit}
+nav .nav-link:hover,nav .nav-link:focus{background:#eef3ff;outline:2px solid var(--accent);outline-offset:1px}
+main{padding:1.25rem 1.5rem}
+.panel[hidden]{display:none}
+.badge{display:inline-block;padding:.15rem .55rem;border-radius:.3rem;font-size:.85rem;font-weight:600}
+.st-safe{color:var(--safe)}.st-warn{color:var(--warn)}.st-unsafe{color:var(--unsafe)}.st-unknown{color:var(--unknown)}
+table{border-collapse:collapse;width:100%;max-width:48rem;background:#fff}
+th,td{border:1px solid var(--line);padding:.4rem .55rem;text-align:left;vertical-align:top}
+th{background:#f0f0ec}
+.summary-md,pre.data{white-space:pre-wrap;word-break:break-word;background:#fff;border:1px solid var(--line);padding:.75rem;max-width:52rem}
+.muted{color:var(--muted)}
+ul.runs{margin:.4rem 0 1rem;padding-left:1.2rem}
+@media print{
+  nav{display:none}
+  .layout{display:block}
+  .panel[hidden]{display:block!important;page-break-before:always}
+  header{border:0}
+}
+@media (max-width:720px){
+  .layout{grid-template-columns:1fr}
+  nav{border-right:0;border-bottom:1px solid var(--line);display:flex;flex-wrap:wrap;gap:.25rem}
+}
+${EVIDENCE_VIEW_CSS}
+</style>
+</head>
+<body>
+<header>
+  <h1>${title}</h1>
+  <p class="note">${escapeHtml(EVIDENCE_HTML_NOTE)}</p>
+</header>
+<div class="layout">
+<nav aria-label="Evidence views">
+${nav}
+</nav>
+<main id="main">
+  <section id="view-summary" class="panel" tabindex="-1">
+    <h2>Summary</h2>
+    <p>Artifact status: <span class="badge ${statusClass(input.assessmentStatus)}">${escapeHtml(input.assessmentStatus)}</span>
+    ${input.sourceStatus !== void 0 ? ` \xB7 Source status: <span class="badge ${statusClass(input.sourceStatus)}">${escapeHtml(input.sourceStatus)}</span>` : ""}</p>
+    <p>Profile: <code>${escapeHtml(input.redactionProfile)}</code> \xB7 Verification: <code>${escapeHtml(input.verificationPolicy)}</code></p>
+    <p>Generator: <code>${escapeHtml(input.generatorName)}@${escapeHtml(input.generatorVersion)}</code>
+    ${input.createdAt ? ` \xB7 Created: <code>${escapeHtml(input.createdAt)}</code>` : ""}</p>
+    <h3>Runs</h3>
+    <ul class="runs">${runList}</ul>
+    ${checkRows ? `<h3>Check summary</h3>
+    <table>
+      <thead><tr><th>runId</th><th>artifact</th><th>errors</th><th>warnings</th><th>findings</th></tr></thead>
+      <tbody>${checkRows}</tbody>
+    </table>` : ""}
+    <h3>Text summary</h3>
+    ${summaryBody}
+  </section>
+${stubPanels}
+</main>
+</div>
+<script type="application/json" id="ai-evidence-data">${embedded}</script>
+<script>
+(function(){
+  var links=document.querySelectorAll("nav .nav-link");
+  var panels=document.querySelectorAll("main .panel");
+  function show(id){
+    for(var i=0;i<panels.length;i++){
+      var p=panels[i];
+      var on=p.id==="view-"+id;
+      if(on){p.removeAttribute("hidden");}else{p.setAttribute("hidden","");}
+    }
+    for(var j=0;j<links.length;j++){
+      var a=links[j];
+      if(a.getAttribute("data-view")===id){a.setAttribute("aria-current","page");}
+      else{a.removeAttribute("aria-current");}
+    }
+  }
+  for(var k=0;k<links.length;k++){
+    links[k].addEventListener("click",function(ev){
+      var id=ev.currentTarget.getAttribute("data-view");
+      if(!id)return;
+      ev.preventDefault();
+      if(history.replaceState){history.replaceState(null,"","#view-"+id);}
+      show(id);
+      var panel=document.getElementById("view-"+id);
+      if(panel)panel.focus();
+    });
+  }
+  var hash=(location.hash||"").replace(/^#view-/,"");
+  var initial="summary";
+  for(var n=0;n<links.length;n++){
+    if(links[n].getAttribute("data-view")===hash){initial=hash;break;}
+  }
+  show(initial);
+})();
+</script>
+</body>
+</html>
+`;
+}
+function buildEvidenceHtmlShellFromManifest(manifest, extras) {
+  return buildEvidenceHtmlShell({
+    title: extras?.title,
+    runIds: manifest.source.runIds,
+    assessmentStatus: manifest.assessment.status,
+    sourceStatus: manifest.assessment.sourceStatus,
+    redactionProfile: manifest.policy.redactionProfile,
+    verificationPolicy: manifest.policy.verificationPolicy,
+    generatorName: manifest.generator.name,
+    generatorVersion: manifest.generator.version,
+    createdAt: manifest.createdAt,
+    evidenceFormatVersion: manifest.evidenceFormatVersion,
+    summaryText: extras?.summaryText,
+    checkSummary: extras?.checkSummary,
+    viewBodies: extras?.viewBodies
+  });
+}
+
+// packages/core/src/evidence/views-contract.ts
+function boundMessage(message, max = 200) {
+  const trimmed = message.trim();
+  if (trimmed.length <= max) return trimmed;
+  return `${trimmed.slice(0, max)}\u2026`;
+}
+function buildEvidenceContractsViewHtml(input) {
+  const rows = input.runs.map(
+    (run) => `<tr><td><code>${escapeHtml(run.runId)}</code></td><td>${escapeHtml(run.status)}</td><td>${escapeHtml(run.sourceStatus ?? "\u2014")}</td><td>${run.errors}</td><td>${run.warnings}</td><td>${run.findings}</td></tr>`
+  ).join("");
+  const findings = input.findingSummaries ?? [];
+  const findingRows = findings.length === 0 ? `<p class="muted">No structured check findings recorded for the redacted artifact.</p>` : `<table>
+  <thead><tr><th>runId</th><th>severity</th><th>rule</th><th>category</th><th>detector</th><th>message</th></tr></thead>
+  <tbody>${findings.map(
+    (f) => `<tr><td><code>${escapeHtml(f.runId)}</code></td><td>${escapeHtml(f.severity)}</td><td><code>${escapeHtml(f.ruleId)}</code></td><td>${escapeHtml(f.category ?? "\u2014")}</td><td>${escapeHtml(f.detector ?? "\u2014")}</td><td>${escapeHtml(boundMessage(f.message))}</td></tr>`
+  ).join("")}</tbody>
+</table>`;
+  return `<p>Aggregate artifact status: <strong>${escapeHtml(input.aggregateStatus)}</strong></p>
+<table>
+  <thead><tr><th>runId</th><th>artifact</th><th>source</th><th>errors</th><th>warnings</th><th>findings</th></tr></thead>
+  <tbody>${rows}</tbody>
+</table>
+<h3>Finding summaries</h3>
+${findingRows}
+<p class="muted">TraceContract / check details are best-effort local results \u2014 not a compliance certification.</p>`;
+}
+function buildEvidenceOutcomesViewHtml(runs) {
+  if (runs.length === 0) {
+    return `<p class="muted">No runs available for outcome extraction.</p>`;
+  }
+  const parts = [];
+  for (const run of runs) {
+    const forRun = run.events.filter((event) => event.runId === run.runId);
+    const summary = summarizeObservedOutcomes(extractOutcomesFromPersistedEvents(forRun));
+    parts.push(`<article class="run-block">`);
+    parts.push(`<h3><code>${escapeHtml(run.runId)}</code></h3>`);
+    parts.push(renderObservedOutcomesHtml(summary));
+    parts.push(`</article>`);
+  }
+  return parts.join("\n");
+}
+function buildEvidenceDiffViewHtml(parts) {
+  if (parts === void 0 || parts.leftEvents.length === 0 || parts.rightEvents.length === 0) {
+    return `<p class="muted">No baseline/candidate pair was supplied for this evidence bundle. Attach two runs (or a reporter baseline) to populate this view.</p>`;
+  }
+  try {
+    const left = persistedInspectEventsToTraceEvents(
+      parts.leftEvents.filter((e) => e.runId === parts.leftRunId)
+    );
+    const right = persistedInspectEventsToTraceEvents(
+      parts.rightEvents.filter((e) => e.runId === parts.rightRunId)
+    );
+    if (left.length === 0 || right.length === 0) {
+      return `<p class="muted">Could not normalize both runs for diff (missing v0.1-compatible events).</p>`;
+    }
+    const result = diffTraceEvents(left, right);
+    const text = renderRunDiff(result, { color: false, verbose: false });
+    return `<p>Comparing <code>${escapeHtml(parts.leftRunId)}</code> \u2192 <code>${escapeHtml(parts.rightRunId)}</code></p>
+<pre class="summary-md">${escapeHtml(text)}</pre>`;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `<p class="muted">Diff unavailable: ${escapeHtml(message)}</p>`;
+  }
+}
+
+// packages/core/src/evidence/views-safety.ts
+function buildEvidenceSafetyViewHtml(input) {
+  const findingRows = (input.findingSummaries ?? []).length === 0 ? `<p class="muted">No safety findings on the redacted artifact.</p>` : `<table>
+  <thead><tr><th>runId</th><th>severity</th><th>category</th><th>detector</th><th>action</th><th>message</th></tr></thead>
+  <tbody>${(input.findingSummaries ?? []).map((f) => {
+    const msg = f.message.length > 160 ? `${f.message.slice(0, 160)}\u2026` : f.message;
+    return `<tr><td><code>${escapeHtml(f.runId)}</code></td><td>${escapeHtml(f.severity)}</td><td>${escapeHtml(f.category ?? "\u2014")}</td><td>${escapeHtml(f.detector ?? "\u2014")}</td><td>${escapeHtml(f.action ?? "\u2014")}</td><td>${escapeHtml(msg)}</td></tr>`;
+  }).join("")}</tbody>
+</table>`;
+  const redactionBlock = input.redaction === void 0 ? `<p class="muted">No redaction report attached.</p>` : `<p>Total redaction findings: <strong>${input.redaction.totalFindings}</strong></p>
+<ul>${input.redaction.runs.map(
+    (run) => `<li><code>${escapeHtml(run.runId)}</code>: ${run.findings} finding(s); detectors: ${escapeHtml(run.detectors.join(", ") || "none")}</li>`
+  ).join("")}</ul>`;
+  return `<p>Artifact status: <strong>${escapeHtml(String(input.artifactStatus))}</strong>
+  ${input.sourceStatus !== void 0 ? ` \xB7 Source status: <strong>${escapeHtml(String(input.sourceStatus))}</strong>` : ""}</p>
+<p>Redaction profile: <code>${escapeHtml(input.redactionProfile)}</code> \xB7 Verification: <code>${escapeHtml(input.verificationPolicy)}</code></p>
+<h3>Redaction</h3>
+${redactionBlock}
+<h3>Safety findings (artifact)</h3>
+${findingRows}
+<p class="muted">Best-effort local verification only \u2014 not a compliance certification. Gate sharing on artifact status.</p>`;
+}
+function buildEvidenceProvenanceViewHtml(input) {
+  const hashes = input.sourceHashes.length === 0 ? `<p class="muted">No source hashes recorded.</p>` : `<table>
+  <thead><tr><th>runId</th><th>algorithm</th><th>hash</th></tr></thead>
+  <tbody>${input.sourceHashes.map(
+    (h) => `<tr><td><code>${escapeHtml(h.runId)}</code></td><td>${escapeHtml(h.algorithm)}</td><td><code>${escapeHtml(h.hash)}</code></td></tr>`
+  ).join("")}</tbody>
+</table>`;
+  const files = input.packagedFiles.length === 0 ? `<p class="muted">No packaged files listed.</p>` : `<ul>${input.packagedFiles.map(
+    (f) => `<li><code>${escapeHtml(f.path)}</code>${f.role ? ` <span class="meta">(${escapeHtml(f.role)})</span>` : ""}</li>`
+  ).join("")}</ul>`;
+  return `<p>Generator: <code>${escapeHtml(input.generatorName)}@${escapeHtml(input.generatorVersion)}</code>
+  \xB7 Evidence format: <code>${escapeHtml(input.evidenceFormatVersion)}</code>
+  ${input.createdAt ? ` \xB7 Created: <code>${escapeHtml(input.createdAt)}</code>` : ""}</p>
+<p>Runs: ${input.runIds.map((id) => `<code>${escapeHtml(id)}</code>`).join(", ")}</p>
+<p>Trace schema versions: ${input.traceSchemaVersions.length > 0 ? input.traceSchemaVersions.map((v) => `<code>${escapeHtml(v)}</code>`).join(", ") : '<span class="muted">unknown</span>'}</p>
+<h3>Source hashes (pre-redaction input)</h3>
+${hashes}
+<h3>Packaged files</h3>
+${files}
+<p class="muted">${escapeHtml(input.note ?? "Reader/mapping losses are reported elsewhere when present; relationships are never invented without confidence policy.")}</p>`;
+}
+function buildEvidenceToolsLlmViewHtml(trees) {
+  if (trees.length === 0) {
+    return `<p class="muted">No runs available for tool/LLM metadata.</p>`;
+  }
+  const parts = [];
+  for (const tree of trees) {
+    const nodes = flattenTree(tree).filter(
+      (n) => n.event.kind === "TOOL" || n.event.kind === "LLM" || n.event.kind === "AGENT"
+    );
+    parts.push(`<article class="run-block">`);
+    parts.push(`<h3><code>${escapeHtml(tree.runId)}</code></h3>`);
+    if (nodes.length === 0) {
+      parts.push(`<p class="muted">No TOOL/LLM/AGENT events in this run.</p>`);
+    } else {
+      parts.push(`<table>
+  <thead><tr><th>name</th><th>kind</th><th>status</th><th>durationMs</th></tr></thead>
+  <tbody>${nodes.map((n) => {
+        const dur = n.event.durationMs !== void 0 && Number.isFinite(n.event.durationMs) ? String(n.event.durationMs) : "\u2014";
+        return `<tr><td>${escapeHtml(n.event.name)}</td><td>${escapeHtml(n.event.kind)}</td><td>${escapeHtml(n.event.status ?? "?")}</td><td>${escapeHtml(dur)}</td></tr>`;
+      }).join("")}</tbody>
+</table>`);
+    }
+    parts.push(`</article>`);
+  }
+  return parts.join("\n");
+}
+function buildEvidenceCircuitViewHtml(parts) {
+  const findings = parts?.findings ?? [];
+  if (findings.length === 0) {
+    return `<p class="muted">No circuit or guardrail findings were attached to this evidence bundle.</p>`;
+  }
+  return `<table>
+  <thead><tr><th>runId</th><th>name</th><th>status</th><th>detail</th></tr></thead>
+  <tbody>${findings.map(
+    (f) => `<tr><td><code>${escapeHtml(f.runId)}</code></td><td>${escapeHtml(f.name)}</td><td>${escapeHtml(f.status)}</td><td>${escapeHtml(f.detail ?? "\u2014")}</td></tr>`
+  ).join("")}</tbody>
+</table>`;
+}
+
+// packages/core/src/evidence/zip.ts
+var CRC_TABLE = (() => {
+  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;
+})();
+function crc32(data) {
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i += 1) {
+    crc = CRC_TABLE[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function toBytes(content) {
+  return typeof content === "string" ? Buffer.from(content, "utf8") : content;
+}
+function u16(value) {
+  const buf = Buffer.alloc(2);
+  buf.writeUInt16LE(value >>> 0, 0);
+  return buf;
+}
+function u32(value) {
+  const buf = Buffer.alloc(4);
+  buf.writeUInt32LE(value >>> 0, 0);
+  return buf;
+}
+function buildZipArchive(entries) {
+  if (entries.length === 0) {
+    throw new Error("ZIP archive requires at least one entry.");
+  }
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const name = assertEvidenceRelativePath(entry.path);
+    if (seen.has(name)) {
+      throw new Error(`Duplicate ZIP entry path: ${name}`);
+    }
+    seen.add(name);
+    const nameBytes = Buffer.from(name, "utf8");
+    const data = toBytes(entry.content);
+    const checksum = crc32(data);
+    const size = data.byteLength;
+    const local = Buffer.concat([
+      u32(67324752),
+      u16(20),
+      // version needed
+      u16(0),
+      // flags
+      u16(0),
+      // method STORE
+      u16(0),
+      // time
+      u16(0),
+      // date
+      u32(checksum),
+      u32(size),
+      u32(size),
+      u16(nameBytes.length),
+      u16(0),
+      // extra length
+      nameBytes,
+      Buffer.from(data)
+    ]);
+    const central = Buffer.concat([
+      u32(33639248),
+      u16(20),
+      // version made by
+      u16(20),
+      // version needed
+      u16(0),
+      u16(0),
+      u16(0),
+      u16(0),
+      u32(checksum),
+      u32(size),
+      u32(size),
+      u16(nameBytes.length),
+      u16(0),
+      u16(0),
+      u16(0),
+      u16(0),
+      u32(0),
+      u32(offset),
+      nameBytes
+    ]);
+    locals.push(local);
+    centrals.push(central);
+    offset += local.length;
+  }
+  const centralDir = Buffer.concat(centrals);
+  const end = Buffer.concat([
+    u32(101010256),
+    u16(0),
+    u16(0),
+    u16(entries.length),
+    u16(entries.length),
+    u32(centralDir.length),
+    u32(offset),
+    u16(0)
+  ]);
+  return Buffer.concat([...locals, centralDir, end]);
+}
+async function listFilesRecursive(root) {
+  const out = [];
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const abs = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(abs);
+      } else if (entry.isFile()) {
+        const rel = path.relative(root, abs).split(path.sep).join("/");
+        out.push(rel);
+      }
+    }
+  }
+  await walk(root);
+  return out.sort((a, b) => a.localeCompare(b));
+}
+async function verifyEvidenceDirectory(rootPath, options = {}) {
+  const unexpectedMode = options.unexpectedFiles ?? "fail";
+  const root = path.resolve(rootPath);
+  const issues = [];
+  let rootStat;
+  try {
+    rootStat = await stat(root);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      status: "fail",
+      root,
+      issues: [{ code: "io_error", severity: "error", message: `Cannot read path: ${message}` }],
+      checkedFiles: 0
+    };
+  }
+  if (!rootStat.isDirectory()) {
+    return {
+      ok: false,
+      status: "fail",
+      root,
+      issues: [
+        {
+          code: "io_error",
+          severity: "error",
+          message: "Evidence verify expects a directory containing evidence.json (unpack ZIP first)."
+        }
+      ],
+      checkedFiles: 0
+    };
+  }
+  const manifestPath = path.join(root, EVIDENCE_MANIFEST_FILENAME);
+  let manifestText;
+  try {
+    manifestText = await readFile(manifestPath, "utf-8");
+  } catch {
+    return {
+      ok: false,
+      status: "fail",
+      root,
+      issues: [
+        {
+          code: "manifest_missing",
+          severity: "error",
+          message: `Missing ${EVIDENCE_MANIFEST_FILENAME}`,
+          path: EVIDENCE_MANIFEST_FILENAME
+        }
+      ],
+      checkedFiles: 0
+    };
+  }
+  let manifest;
+  try {
+    manifest = parseEvidenceManifestJson(manifestText);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      status: "fail",
+      root,
+      issues: [
+        {
+          code: "manifest_invalid",
+          severity: "error",
+          message,
+          path: EVIDENCE_MANIFEST_FILENAME
+        }
+      ],
+      checkedFiles: 0
+    };
+  }
+  if (!manifest.assessment?.status) {
+    issues.push({
+      code: "assessment_missing",
+      severity: "error",
+      message: "Manifest assessment.status is required."
+    });
+  }
+  if (!manifest.generator?.name || !manifest.generator?.version) {
+    issues.push({
+      code: "provenance_missing",
+      severity: "error",
+      message: "Manifest generator.name and generator.version are required."
+    });
+  }
+  if (!manifest.source?.runIds?.length) {
+    issues.push({
+      code: "provenance_missing",
+      severity: "error",
+      message: "Manifest source.runIds must be non-empty."
+    });
+  }
+  const listed = /* @__PURE__ */ new Set();
+  for (const file of manifest.files) {
+    let rel;
+    try {
+      rel = assertEvidenceRelativePath(file.path);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      issues.push({
+        code: "path_unsafe",
+        severity: "error",
+        message,
+        path: file.path
+      });
+      continue;
+    }
+    if (rel === EVIDENCE_MANIFEST_FILENAME) {
+      issues.push({
+        code: "manifest_invalid",
+        severity: "error",
+        message: `${EVIDENCE_MANIFEST_FILENAME} must not list itself in files[].`,
+        path: rel
+      });
+      continue;
+    }
+    listed.add(rel);
+    const abs = path.join(root, ...rel.split("/"));
+    let bytes;
+    try {
+      bytes = await readFile(abs);
+    } catch {
+      issues.push({
+        code: "file_missing",
+        severity: "error",
+        message: `Listed file missing: ${rel}`,
+        path: rel
+      });
+      continue;
+    }
+    const actual = sha256Hex(bytes);
+    if (!sha256Equals(file.sha256, actual)) {
+      issues.push({
+        code: "hash_mismatch",
+        severity: "error",
+        message: `SHA-256 mismatch for ${rel}`,
+        path: rel
+      });
+    }
+  }
+  let onDisk = [];
+  try {
+    onDisk = await listFilesRecursive(root);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    issues.push({ code: "io_error", severity: "error", message });
+  }
+  for (const rel of onDisk) {
+    if (rel === EVIDENCE_MANIFEST_FILENAME) continue;
+    if (listed.has(rel)) continue;
+    if (unexpectedMode === "ignore") continue;
+    issues.push({
+      code: "file_unexpected",
+      severity: unexpectedMode === "warn" ? "warning" : "error",
+      message: `Unexpected file not listed in manifest: ${rel}`,
+      path: rel
+    });
+  }
+  const hasError = issues.some((issue) => issue.severity === "error");
+  return {
+    ok: !hasError,
+    status: hasError ? "fail" : "pass",
+    root,
+    manifest,
+    issues,
+    checkedFiles: listed.size
+  };
+}
+
+// packages/core/src/evidence/ci.ts
+function asMap(value) {
+  if (value instanceof Map) return new Map(value);
+  return new Map(Object.entries(value));
+}
+function buildEvidenceCiPackage(input) {
+  const sources = asMap(input.sourceContents);
+  const sourceHashes = input.runIds.map((runId) => ({
+    runId,
+    algorithm: "sha256",
+    hash: sha256Hex(sources.get(runId) ?? "")
+  }));
+  const schemaVersions = /* @__PURE__ */ new Set();
+  for (const content of sources.values()) {
+    for (const version of collectTraceSchemaVersions(content)) {
+      schemaVersions.add(version);
+    }
+  }
+  for (const version of collectTraceSchemaVersions(input.redactedTraceJsonl)) {
+    schemaVersions.add(version);
+  }
+  const createdAt = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const evidenceHtml = buildEvidenceHtmlShell({
+    title: "AgentInspect evidence",
+    runIds: input.runIds,
+    assessmentStatus: input.assessmentStatus,
+    sourceStatus: input.sourceStatus,
+    redactionProfile: input.redactionProfile,
+    verificationPolicy: input.redactionProfile,
+    generatorName: "agent-inspect",
+    generatorVersion: input.generatorVersion,
+    createdAt,
+    summaryText: input.summaryText,
+    checkSummary: {
+      aggregateStatus: input.assessmentStatus,
+      runs: input.runIds.map((runId) => ({
+        runId,
+        status: input.assessmentStatus,
+        sourceStatus: input.sourceStatus,
+        errors: input.assessmentStatus === "UNSAFE" || input.assessmentStatus === "UNKNOWN" ? 1 : 0,
+        warnings: input.assessmentStatus === "SAFE WITH WARNINGS" ? 1 : 0,
+        findings: 0
+      }))
+    }
+  });
+  const packaged = [
+    { path: EVIDENCE_HTML_FILENAME, content: evidenceHtml },
+    { path: "check-results.json", content: input.checkResultsJson },
+    { path: "trace.jsonl", content: input.redactedTraceJsonl }
+  ];
+  const manifest = buildEvidenceManifest({
+    generatorVersion: input.generatorVersion,
+    runIds: input.runIds,
+    traceSchemaVersions: [...schemaVersions].sort((a, b) => a.localeCompare(b)),
+    sourceHashes,
+    redactionProfile: input.redactionProfile,
+    verificationPolicy: input.redactionProfile,
+    assessmentStatus: input.assessmentStatus,
+    sourceStatus: input.sourceStatus,
+    files: packaged,
+    createdAt,
+    note: EVIDENCE_ASSESSMENT_NOTE
+  });
+  return {
+    "evidence.html": evidenceHtml,
+    "evidence.json": serializeEvidenceManifest(manifest),
+    "check-results.json": input.checkResultsJson,
+    "trace.jsonl": input.redactedTraceJsonl,
+    manifest
+  };
+}
+
 // packages/core/src/suite/types.ts
 var DEFAULT_SUITE_CONFIG_NAMES = [
   "agent-inspect.suite.json",
@@ -3099,6 +4252,6 @@ function renderGateReport(result, options = {}) {
   return renderGateSummaryMarkdown(result);
 }
 
-export { COHORT_METRIC_IDS, DEFAULT_SUITE_ARTIFACTS_DIR, DEFAULT_SUITE_CONFIG_NAMES, SESSION_WORKFLOW_KEYS, SUITE_TEMPLATE_IDS, aggregateBundleSafeStatus, aggregateSessionCheckResults, analyzeCohort, assertBundlePathContained, buildActivitySummary, buildBundleMetadata, buildBundleSummaryMarkdown, buildLocalExplanation, buildPlaceholderArtifact, buildSessionIndex, bundleFailsOnSafety, bundleRunAssetRelativePath, compareCohortAggregates, defaultBundleOutputPath, defaultSuiteConfigTemplate, deriveSessionStatus, enrichSessionRunRecord, enrichSessionSummary, extractSessionWorkflowMetadata, filterMetasBySessionScope, gateHasThresholds, getSuiteTemplate, groupSessionCohorts, isAgentInspectTrace, listSuiteTemplates, loadSessionRunRecords, loadSuiteConfig, loadTraceMetadataList, normalizeBundleOutputPath, normalizeSuiteConfig, parseCohortMetricList, parseDurationFilter, parseGateList, parseGateNumber, parseGroupBySpec, renderActivitySummaryHuman, renderCohortReport, renderCohortSummaryMarkdown, renderGateGithubStepSummary, renderGateJUnit, renderGateReport, renderGateSummaryMarkdown, renderSuiteReport, renderSuiteReportMarkdown, resolveBundleRunIds, resolveSuiteCaseTrace, resolveSuiteConfigPath, resolveSuiteTemplate, runGate, runSuite, sanitizeBundleRunId, searchTraces, sessionKeyForRun, toMetadataSafeStatus, traceMetasToSessionRunRecords, validateSuiteConfig };
+export { COHORT_METRIC_IDS, DEFAULT_SUITE_ARTIFACTS_DIR, DEFAULT_SUITE_CONFIG_NAMES, EVIDENCE_ASSESSMENT_NOTE, EVIDENCE_FORMAT_VERSION, EVIDENCE_HTML_FILENAME, EVIDENCE_MANIFEST_FILENAME, EVIDENCE_VIEW_CSS, EVIDENCE_VIEW_IDS, SESSION_WORKFLOW_KEYS, SUITE_TEMPLATE_IDS, aggregateBundleSafeStatus, aggregateSessionCheckResults, analyzeCohort, assertBundlePathContained, assertEvidenceRelativePath, buildActivitySummary, buildBundleMetadata, buildBundleSummaryMarkdown, buildEvidenceCausalFailureViewHtml, buildEvidenceCiPackage, buildEvidenceCircuitViewHtml, buildEvidenceContractsViewHtml, buildEvidenceDiffViewHtml, buildEvidenceFileEntries, buildEvidenceHtmlShell, buildEvidenceHtmlShellFromManifest, buildEvidenceManifest, buildEvidenceOutcomesViewHtml, buildEvidenceProvenanceViewHtml, buildEvidenceSafetyViewHtml, buildEvidenceTimelineViewHtml, buildEvidenceToolsLlmViewHtml, buildEvidenceTreeViewHtml, buildLocalExplanation, buildPlaceholderArtifact, buildSessionIndex, buildZipArchive, bundleFailsOnSafety, bundleRunAssetRelativePath, collectTraceSchemaVersions, compareCohortAggregates, defaultBundleOutputPath, defaultSuiteConfigTemplate, deriveSessionStatus, encodeEmbeddedEvidenceJson, enrichSessionRunRecord, enrichSessionSummary, extractSessionWorkflowMetadata, filterMetasBySessionScope, gateHasThresholds, getSuiteTemplate, groupSessionCohorts, inferEvidenceFileRole, isAgentInspectTrace, isSha256Hex, listSuiteTemplates, loadSessionRunRecords, loadSuiteConfig, loadTraceMetadataList, normalizeBundleOutputPath, normalizeSuiteConfig, parseCohortMetricList, parseDurationFilter, parseEvidenceManifestJson, parseGateList, parseGateNumber, parseGroupBySpec, renderActivitySummaryHuman, renderCohortReport, renderCohortSummaryMarkdown, renderGateGithubStepSummary, renderGateJUnit, renderGateReport, renderGateSummaryMarkdown, renderSuiteReport, renderSuiteReportMarkdown, resolveBundleRunIds, resolveSuiteCaseTrace, resolveSuiteConfigPath, resolveSuiteTemplate, runGate, runSuite, sanitizeBundleRunId, searchTraces, serializeEvidenceManifest, sessionKeyForRun, sha256Equals, sha256Hex, toMetadataSafeStatus, traceMetasToSessionRunRecords, validateEvidenceManifest, validateSuiteConfig, verifyEvidenceDirectory };
 //# sourceMappingURL=advanced.mjs.map
 //# sourceMappingURL=advanced.mjs.map