agent-inspect 6.9.0 → 6.11.0

package/packages/core/dist/advanced.cjs

@@ -711,6 +711,15 @@ function persistedInspectEventToTraceEvents(event) {
   }
   return fromNativeStep(event);
 }
+function persistedInspectEventsToTraceEvents(events, options) {
+  const out = [];
+  events.forEach((event, index) => {
+    const rows = persistedInspectEventToTraceEvents(event);
+    if (rows.length === 0 && options?.eventIndex !== void 0) ;
+    out.push(...rows);
+  });
+  return out;
+}
 
 // node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/url-alphabet/index.js
 var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
@@ -2131,6 +2140,20 @@ function extractOutcomesFromPersistedEvents(events) {
   }
   return out.sort((a, b) => a.observedAt - b.observedAt || a.name.localeCompare(b.name));
 }
+function summarizeObservedOutcomes(outcomes) {
+  const summary = {
+    total: outcomes.length,
+    passed: 0,
+    failed: 0,
+    unknown: 0,
+    skipped: 0,
+    outcomes: [...outcomes]
+  };
+  for (const outcome of outcomes) {
+    summary[outcome.status] += 1;
+  }
+  return summary;
+}
 function outcomesMatchingStatus(outcomes, statuses) {
   const set = new Set(statuses);
   return outcomes.filter((outcome) => set.has(outcome.status));
@@ -2140,6 +2163,18 @@ function parseObservationFilter(value) {
   return parseObservedOutcomeStatus(value);
 }
 
+// packages/core/src/outcomes/render.ts
+function renderObservedOutcomesHtml(summary) {
+  if (summary.total === 0) {
+    return "<p>No observed outcomes recorded for this run.</p>";
+  }
+  const rows = summary.outcomes.map((outcome) => {
+    const esc = (v) => v.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+    return `<tr><td>${esc(outcome.name)}</td><td>${esc(outcome.status)}</td><td>${esc(outcome.expectation)}</td><td>${esc(outcome.method ?? "-")}</td></tr>`;
+  }).join("");
+  return `<p>Total: ${summary.total} (passed ${summary.passed}, failed ${summary.failed}, unknown ${summary.unknown}, skipped ${summary.skipped})</p><table><thead><tr><th>Name</th><th>Status</th><th>Expectation</th><th>Method</th></tr></thead><tbody>${rows}</tbody></table>`;
+}
+
 // packages/core/src/inspector.ts
 var INSPECTOR_PERSISTED_SCHEMA_VERSION = "1.0";
 function normalizeName2(name, fallback) {
@@ -3898,6 +3933,148 @@ function renderRunWhat(summary, options = {}) {
   return lines.join("\n");
 }
 
+// packages/core/src/causal-failure.ts
+function runIdFromEvents(events) {
+  for (const event of events) {
+    if ("runId" in event && typeof event.runId === "string") return event.runId;
+  }
+  return void 0;
+}
+function noneResult(runId, rationale) {
+  return {
+    kind: "none",
+    evidenceIds: [],
+    rationale,
+    orderIndex: 0,
+    runId,
+    engine: "conservative-causal-v1"
+  };
+}
+function findFirstCausalFailure(events, options = {}) {
+  const runId = runIdFromEvents(events);
+  const timeline = buildRunTimeline(events);
+  const firstError = timeline.entries.find((entry) => entry.isError);
+  if (firstError) {
+    return {
+      kind: "explicit_error_event",
+      evidenceIds: [firstError.stepId],
+      rationale: "First timeline step with status error (explicit failure; no timing-only inference).",
+      orderIndex: 1,
+      runId: timeline.runId || runId,
+      primary: {
+        stepId: firstError.stepId,
+        name: firstError.name
+      },
+      relationship: { role: "self", relatedIds: [] },
+      engine: "conservative-causal-v1"
+    };
+  }
+  const runCompletedError = events.find(
+    (event) => event.event === "run_completed" && event.status === "error"
+  );
+  if (runCompletedError) {
+    return {
+      kind: "explicit_error_event",
+      evidenceIds: [runCompletedError.runId],
+      rationale: "Run completed with status error and no earlier errored step.",
+      orderIndex: 1,
+      runId: runCompletedError.runId,
+      primary: { name: "run", stepId: runCompletedError.runId },
+      relationship: { role: "self", relatedIds: [] },
+      engine: "conservative-causal-v1"
+    };
+  }
+  const outcomes = extractOutcomesFromTraceEvents(events);
+  const failedOutcome = outcomes.find((outcome) => outcome.status === "failed");
+  if (failedOutcome) {
+    const evidenceIds = [failedOutcome.outcomeId];
+    if (failedOutcome.parentId) evidenceIds.push(failedOutcome.parentId);
+    return {
+      kind: "failed_observed_outcome",
+      evidenceIds,
+      rationale: "First observed outcome with status failed.",
+      orderIndex: 2,
+      runId: failedOutcome.runId || runId,
+      primary: {
+        outcomeId: failedOutcome.outcomeId,
+        stepId: failedOutcome.parentId,
+        name: failedOutcome.name
+      },
+      relationship: failedOutcome.parentId ? { role: "child", relatedIds: [failedOutcome.parentId] } : { role: "self", relatedIds: [] },
+      engine: "conservative-causal-v1"
+    };
+  }
+  const contractFail = (options.contractFindings ?? []).find(
+    (finding) => finding.status === "fail" && (finding.evidenceIds?.length ?? 0) > 0
+  );
+  if (contractFail) {
+    const evidenceIds = [...contractFail.evidenceIds ?? []];
+    return {
+      kind: "contract_failure",
+      evidenceIds,
+      rationale: contractFail.message ?? `Contract rule ${contractFail.ruleId} failed with linked evidence ids.`,
+      orderIndex: 3,
+      runId,
+      primary: {
+        ruleId: contractFail.ruleId,
+        stepId: evidenceIds[0],
+        name: contractFail.ruleId
+      },
+      relationship: { role: "self", relatedIds: [] },
+      engine: "conservative-causal-v1"
+    };
+  }
+  const completed = events.filter(
+    (event) => event.event === "step_completed"
+  );
+  const started = events.filter(
+    (event) => event.event === "step_started"
+  );
+  const parentByStep = /* @__PURE__ */ new Map();
+  for (const start of started) {
+    parentByStep.set(start.stepId, start.parentId);
+  }
+  const errorSteps = completed.filter((event) => event.status === "error");
+  if (errorSteps.length > 0) {
+    const sorted = [...errorSteps].sort((a, b) => {
+      const depth = (id) => {
+        let d = 0;
+        let cur = id;
+        const seen = /* @__PURE__ */ new Set();
+        while (cur && parentByStep.has(cur) && !seen.has(cur)) {
+          seen.add(cur);
+          const parent = parentByStep.get(cur);
+          if (!parent) break;
+          d += 1;
+          cur = parent;
+        }
+        return d;
+      };
+      return depth(b.stepId) - depth(a.stepId);
+    });
+    const tip = sorted[0];
+    const parentId = parentByStep.get(tip.stepId);
+    const relatedIds = parentId ? [parentId] : [];
+    return {
+      kind: "failed_ancestor_or_child",
+      evidenceIds: [tip.stepId, ...relatedIds],
+      rationale: parentId ? "Deepest explicit error step with parent link (nearest ancestor relationship)." : "Explicit error step used as structural tip (no parent id).",
+      orderIndex: 4,
+      runId: tip.runId || runId,
+      primary: { stepId: tip.stepId, name: started.find((s) => s.stepId === tip.stepId)?.name },
+      relationship: {
+        role: parentId ? "child" : "self",
+        relatedIds
+      },
+      engine: "conservative-causal-v1"
+    };
+  }
+  return noneResult(
+    runId,
+    "No explicit error event, failed outcome, or linked contract failure; refusing timing-only inference."
+  );
+}
+
 // packages/core/src/explain.ts
 function toDisplayStatus(status) {
   if (status === "ok") return "success";
@@ -4986,12 +5163,12 @@ function buildCriticalPath(runs, handoffs) {
     handoffs.filter((edge) => edge.confidence === "explicit").map((edge) => edge.from)
   );
   const ordered = [...runs].sort(compareRuns);
-  const path12 = [];
+  const path14 = [];
   const visited = /* @__PURE__ */ new Set();
   const pushRun = (run, confidence, source) => {
     if (visited.has(run.runId)) return;
     visited.add(run.runId);
-    path12.push({
+    path14.push({
       runId: run.runId,
       name: run.name,
       startedAt: run.startedAt,
@@ -5016,7 +5193,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 path14;
 }
 function metaRunIdMatches(run, token, runById) {
   const meta = extractSessionWorkflowMetadata(run.metadata);
@@ -5326,13 +5503,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 = path5__default.default.resolve(trimmed);
-  if (resolved.toLowerCase().endsWith(".zip")) {
+  if (options?.preserveZipExtension !== true && resolved.toLowerCase().endsWith(".zip")) {
     return resolved.slice(0, -4);
   }
   return resolved;
@@ -5343,6 +5520,1634 @@ function defaultBundleOutputPath(runIds) {
   return path5__default.default.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 = crypto.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 (path5__default.default.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/exporters/helpers.ts
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+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);
+}
+function flattenTree(tree) {
+  const out = [];
+  function walk(nodes) {
+    for (const n of nodes) {
+      out.push(n);
+      if (n.children.length > 0) walk(n.children);
+    }
+  }
+  walk(tree.children);
+  return out;
+}
+
+// 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 durationMs2 = 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: durationMs2,
+      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/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 durationMs2 = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const steps = /* @__PURE__ */ new Map();
+  let order = 0;
+  for (const e of events) {
+    if (e.event !== "step_started") continue;
+    const s = e;
+    const meta = s.metadata ? { ...s.metadata } : void 0;
+    steps.set(s.stepId, {
+      id: s.stepId,
+      parentId: s.parentId,
+      name: s.name,
+      type: s.type,
+      order: order++,
+      timestamp: s.timestamp,
+      metadata: meta
+    });
+  }
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const acc = steps.get(e.stepId);
+    if (!acc) continue;
+    acc.status = e.status;
+    acc.durationMs = e.durationMs;
+    if (e.error?.message) acc.errorMsg = e.error.message;
+    const extra = e;
+    if (extra.metadata !== void 0 && typeof extra.metadata === "object") {
+      acc.metadata = { ...acc.metadata ?? {}, ...extra.metadata };
+    }
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  for (const acc of steps.values()) {
+    let meta = acc.metadata ? { ...acc.metadata } : void 0;
+    if (acc.parentId !== void 0 && !steps.has(acc.parentId)) {
+      meta = { ...meta ?? {}, agent_inspect_diff_parent_missing: true };
+    }
+    const outputPreview = extractOutputPreview(meta);
+    if (meta !== void 0 && ("outputPreview" in meta || "resultPreview" in meta)) {
+      delete meta.outputPreview;
+      delete meta.resultPreview;
+    }
+    const sc = {
+      id: acc.id,
+      name: acc.name,
+      type: acc.type,
+      status: mapStepStatus(acc.status),
+      durationMs: acc.durationMs,
+      error: acc.errorMsg,
+      metadata: meta && Object.keys(meta).length > 0 ? meta : void 0,
+      outputPreview,
+      children: []
+    };
+    nodes.set(acc.id, sc);
+  }
+  const roots = [];
+  const sortByOrder = (a, b) => {
+    const oa = steps.get(a.id)?.order ?? 0;
+    const ob = steps.get(b.id)?.order ?? 0;
+    return oa - ob;
+  };
+  for (const acc of steps.values()) {
+    const node = nodes.get(acc.id);
+    if (acc.parentId !== void 0 && nodes.has(acc.parentId)) {
+      nodes.get(acc.parentId).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  roots.sort(sortByOrder);
+  for (const n of nodes.values()) {
+    n.children.sort(sortByOrder);
+  }
+  return {
+    runId,
+    name: rs.name,
+    status: runStatus,
+    durationMs: durationMs2,
+    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 path14 = buildPath(segments);
+  if (L.name !== R.name) {
+    out.push({
+      kind: "structure",
+      severity: "warning",
+      message: "Step name differs",
+      path: path14,
+      left: L.name,
+      right: R.name
+    });
+  }
+  if ((L.type ?? "") !== (R.type ?? "")) {
+    out.push({
+      kind: "step-type",
+      severity: "warning",
+      message: "Step type differs",
+      path: path14,
+      left: L.type,
+      right: R.type
+    });
+  }
+  if ((L.status ?? "") !== (R.status ?? "")) {
+    out.push({
+      kind: "step-status",
+      severity: "warning",
+      message: "Step status differs",
+      path: path14,
+      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: path14,
+      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: path14,
+        left: ld,
+        right: rd
+      });
+    }
+  }
+  const lm = stableJson(L.metadata ?? {});
+  const rm = stableJson(R.metadata ?? {});
+  if (lm !== rm) {
+    out.push({
+      kind: "metadata",
+      severity: "info",
+      message: "Step metadata differs",
+      path: path14,
+      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: path14,
+      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/core/src/diff/renderer.ts
+function formatPath(path14) {
+  if (path14 === void 0 || path14.path.length === 0) {
+    return "(run)";
+  }
+  return path14.path.map((s) => s.name).join(" > ");
+}
+function formatValue(v, verbose) {
+  if (v === void 0) return "(undefined)";
+  if (typeof v === "string") return v;
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  const s = JSON.stringify(v);
+  if (s.length <= 120) return s;
+  return `${s.slice(0, 117)}...`;
+}
+function renderRunDiff(result, options) {
+  const json = options?.json === true;
+  if (json) {
+    return JSON.stringify(result, null, 2);
+  }
+  const sev = (s, level) => {
+    return s;
+  };
+  const lines = [];
+  const { summary } = result;
+  lines.push("Run diff");
+  lines.push(`Left:  ${summary.leftRunId}`);
+  lines.push(`Right: ${summary.rightRunId}`);
+  lines.push("");
+  lines.push("Summary:");
+  lines.push(`  Differences: ${summary.totalDifferences}`);
+  lines.push(`  Errors: ${summary.errors}`);
+  lines.push(`  Warnings: ${summary.warnings}`);
+  lines.push(`  Info: ${summary.info}`);
+  lines.push("");
+  const fd = summary.firstDivergence;
+  const firstKind = result.differences[0]?.kind;
+  if (fd !== void 0) {
+    lines.push("First divergence:");
+    const where = formatPath(fd.path);
+    const displayKind = firstKind ?? fd.kind;
+    lines.push(`  ${displayKind} at ${where}`);
+    if (fd.left !== void 0 || fd.right !== void 0) {
+      lines.push(`    left: ${formatValue(fd.left)}`);
+      lines.push(`    right: ${formatValue(fd.right)}`);
+    }
+    lines.push("");
+  }
+  lines.push("Differences:");
+  if (result.differences.length === 0) {
+    lines.push("  (none)");
+    return lines.join("\n");
+  }
+  const showSides = (kind) => [
+    "run-status",
+    "step-status",
+    "error",
+    "duration",
+    "step-type",
+    "structure",
+    "step-added",
+    "step-removed"
+  ].includes(kind);
+  for (const d of result.differences) {
+    const tag = sev(`[${d.severity}]`, d.severity);
+    const pathStr = d.path !== void 0 ? ` ${formatPath(d.path)}` : "";
+    lines.push(`  ${tag} ${d.kind}${pathStr}`);
+    lines.push(`    ${d.message}`);
+    if (d.left !== void 0 || d.right !== void 0) {
+      if (showSides(d.kind)) {
+        lines.push(`    left: ${formatValue(d.left)}`);
+        lines.push(`    right: ${formatValue(d.right)}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// packages/core/src/diff/index.ts
+function diffTraceEvents(leftEvents, rightEvents, options) {
+  const left = manualTraceEventsToComparableRun(leftEvents);
+  const right = manualTraceEventsToComparableRun(rightEvents);
+  return diffRuns(left, right);
+}
+
+// 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 promises.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const abs = path5__default.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(abs);
+      } else if (entry.isFile()) {
+        const rel = path5__default.default.relative(root, abs).split(path5__default.default.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 = path5__default.default.resolve(rootPath);
+  const issues = [];
+  let rootStat;
+  try {
+    rootStat = await promises.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 = path5__default.default.join(root, EVIDENCE_MANIFEST_FILENAME);
+  let manifestText;
+  try {
+    manifestText = await promises.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 = path5__default.default.join(root, ...rel.split("/"));
+    let bytes;
+    try {
+      bytes = await promises.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",
@@ -5866,7 +7671,7 @@ function stripPrefix(name, prefixes) {
   }
   return name;
 }
-function eventEvidence(event, path12) {
+function eventEvidence(event, path14) {
   return {
     runId: event.runId,
     eventId: event.eventId,
@@ -5876,7 +7681,7 @@ function eventEvidence(event, path12) {
     kind: event.kind,
     name: event.name,
     status: event.status,
-    ...path12 ? { path: path12 } : {}
+    ...path14 ? { path: path14 } : {}
   };
 }
 function runEvidence(run) {
@@ -9080,11 +10885,6 @@ async function analyzeCohort(runsInput, options) {
   };
 }
 
-// packages/core/src/exporters/helpers.ts
-function escapeHtml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-
 // packages/core/src/cohort/render.ts
 function formatRate(value) {
   if (value === void 0) return "n/a";
@@ -9716,6 +11516,12 @@ exports.DEFAULT_MAX_PREVIEW_LENGTH = DEFAULT_MAX_PREVIEW_LENGTH;
 exports.DEFAULT_SUITE_ARTIFACTS_DIR = DEFAULT_SUITE_ARTIFACTS_DIR;
 exports.DEFAULT_SUITE_CONFIG_NAMES = DEFAULT_SUITE_CONFIG_NAMES;
 exports.DEFAULT_TRACE_DIR_NAME = DEFAULT_TRACE_DIR_NAME;
+exports.EVIDENCE_ASSESSMENT_NOTE = EVIDENCE_ASSESSMENT_NOTE;
+exports.EVIDENCE_FORMAT_VERSION = EVIDENCE_FORMAT_VERSION;
+exports.EVIDENCE_HTML_FILENAME = EVIDENCE_HTML_FILENAME;
+exports.EVIDENCE_MANIFEST_FILENAME = EVIDENCE_MANIFEST_FILENAME;
+exports.EVIDENCE_VIEW_CSS = EVIDENCE_VIEW_CSS;
+exports.EVIDENCE_VIEW_IDS = EVIDENCE_VIEW_IDS;
 exports.FALLBACK_TRACE_DIR = FALLBACK_TRACE_DIR;
 exports.MAX_NAME_LENGTH = MAX_NAME_LENGTH;
 exports.MAX_TERMINAL_DEPTH = MAX_TERMINAL_DEPTH;
@@ -9729,9 +11535,25 @@ exports.aggregateBundleSafeStatus = aggregateBundleSafeStatus;
 exports.aggregateSessionCheckResults = aggregateSessionCheckResults;
 exports.analyzeCohort = analyzeCohort;
 exports.assertBundlePathContained = assertBundlePathContained;
+exports.assertEvidenceRelativePath = assertEvidenceRelativePath;
 exports.buildActivitySummary = buildActivitySummary;
 exports.buildBundleMetadata = buildBundleMetadata;
 exports.buildBundleSummaryMarkdown = buildBundleSummaryMarkdown;
+exports.buildEvidenceCausalFailureViewHtml = buildEvidenceCausalFailureViewHtml;
+exports.buildEvidenceCiPackage = buildEvidenceCiPackage;
+exports.buildEvidenceCircuitViewHtml = buildEvidenceCircuitViewHtml;
+exports.buildEvidenceContractsViewHtml = buildEvidenceContractsViewHtml;
+exports.buildEvidenceDiffViewHtml = buildEvidenceDiffViewHtml;
+exports.buildEvidenceFileEntries = buildEvidenceFileEntries;
+exports.buildEvidenceHtmlShell = buildEvidenceHtmlShell;
+exports.buildEvidenceHtmlShellFromManifest = buildEvidenceHtmlShellFromManifest;
+exports.buildEvidenceManifest = buildEvidenceManifest;
+exports.buildEvidenceOutcomesViewHtml = buildEvidenceOutcomesViewHtml;
+exports.buildEvidenceProvenanceViewHtml = buildEvidenceProvenanceViewHtml;
+exports.buildEvidenceSafetyViewHtml = buildEvidenceSafetyViewHtml;
+exports.buildEvidenceTimelineViewHtml = buildEvidenceTimelineViewHtml;
+exports.buildEvidenceToolsLlmViewHtml = buildEvidenceToolsLlmViewHtml;
+exports.buildEvidenceTreeViewHtml = buildEvidenceTreeViewHtml;
 exports.buildLocalExplanation = buildLocalExplanation;
 exports.buildPlaceholderArtifact = buildPlaceholderArtifact;
 exports.buildRunSummary = buildRunSummary;
@@ -9739,8 +11561,10 @@ exports.buildRunTimeline = buildRunTimeline;
 exports.buildRunWhatSummary = buildRunWhatSummary;
 exports.buildSessionIndex = buildSessionIndex;
 exports.buildTraceStats = buildTraceStats;
+exports.buildZipArchive = buildZipArchive;
 exports.bundleFailsOnSafety = bundleFailsOnSafety;
 exports.bundleRunAssetRelativePath = bundleRunAssetRelativePath;
+exports.collectTraceSchemaVersions = collectTraceSchemaVersions;
 exports.compareCohortAggregates = compareCohortAggregates;
 exports.createInspector = createInspector;
 exports.createInspectorRuntime = createInspectorRuntime;
@@ -9749,6 +11573,7 @@ exports.createStepId = createStepId;
 exports.defaultBundleOutputPath = defaultBundleOutputPath;
 exports.defaultSuiteConfigTemplate = defaultSuiteConfigTemplate;
 exports.deriveSessionStatus = deriveSessionStatus;
+exports.encodeEmbeddedEvidenceJson = encodeEmbeddedEvidenceJson;
 exports.enrichSessionRunRecord = enrichSessionRunRecord;
 exports.enrichSessionSummary = enrichSessionSummary;
 exports.ensureTraceDir = ensureTraceDir;
@@ -9758,6 +11583,7 @@ exports.extractOutcomesFromTraceEvents = extractOutcomesFromTraceEvents;
 exports.extractSessionWorkflowMetadata = extractSessionWorkflowMetadata;
 exports.filterMetasBySessionScope = filterMetasBySessionScope;
 exports.filterTraces = filterTraces;
+exports.findFirstCausalFailure = findFirstCausalFailure;
 exports.formatDuration = formatDuration2;
 exports.formatError = formatError;
 exports.formatTerminalName = formatTerminalName;
@@ -9779,9 +11605,11 @@ exports.getTraceFilePath = getTraceFilePath;
 exports.getTraceSafetyFromContext = getTraceSafetyFromContext;
 exports.groupSessionCohorts = groupSessionCohorts;
 exports.hasActiveContext = hasActiveContext;
+exports.inferEvidenceFileRole = inferEvidenceFileRole;
 exports.initializeTraceFile = initializeTraceFile;
 exports.isAgentInspectEnabled = isAgentInspectEnabled;
 exports.isAgentInspectTrace = isAgentInspectTrace;
+exports.isSha256Hex = isSha256Hex;
 exports.isSilentContext = isSilentContext;
 exports.isStepStatus = isStepStatus;
 exports.isStepType = isStepType;
@@ -9797,6 +11625,7 @@ exports.normalizeSuiteConfig = normalizeSuiteConfig;
 exports.parseCohortMetricList = parseCohortMetricList;
 exports.parseDuration = parseDuration;
 exports.parseDurationFilter = parseDurationFilter;
+exports.parseEvidenceManifestJson = parseEvidenceManifestJson;
 exports.parseGateList = parseGateList;
 exports.parseGateNumber = parseGateNumber;
 exports.parseGroupBySpec = parseGroupBySpec;
@@ -9840,13 +11669,18 @@ exports.runWithStepContext = runWithStepContext;
 exports.sanitizeBundleRunId = sanitizeBundleRunId;
 exports.searchTraces = searchTraces;
 exports.serializeEvent = serializeEvent;
+exports.serializeEvidenceManifest = serializeEvidenceManifest;
 exports.sessionKeyForRun = sessionKeyForRun;
+exports.sha256Equals = sha256Equals;
+exports.sha256Hex = sha256Hex;
 exports.toMetadataSafeStatus = toMetadataSafeStatus;
 exports.traceMetasToSessionRunRecords = traceMetasToSessionRunRecords;
 exports.truncateName = truncateName;
 exports.unknownTraceFormatMessage = unknownTraceFormatMessage;
 exports.validateEvent = validateEvent;
+exports.validateEvidenceManifest = validateEvidenceManifest;
 exports.validateSuiteConfig = validateSuiteConfig;
+exports.verifyEvidenceDirectory = verifyEvidenceDirectory;
 exports.warn = warn;
 exports.writeTraceEvent = writeTraceEvent;
 //# sourceMappingURL=advanced.cjs.map