@tangle-network/traces 0.11.5 → 0.11.6

package/dist/{chunk-VTYOCFGF.js → chunk-MEAEXKUV.js}

@@ -3,6 +3,145 @@ function appendAll(target, values) {
   for (const value of values) target.push(value);
 }
 
+// src/attributes.ts
+var ATTR = {
+  /** = the trace/session id. Wire contract (dedup linkage). */
+  SESSION_ID: "tangle.sessionId",
+  /** "cli" marks a CLI upload so the platform can drop a re-upload of a session
+   *  that also streamed live. Wire contract. */
+  INGEST_SOURCE: "tangle.ingest_source",
+  HARNESS: "tangle.harness",
+  CWD: "tangle.cwd",
+  /** THE per-session grouping key the spine derives subjects from
+   *  (`deriveSubjectKey` reads `tangle.subject.key` first). Resolves to the git
+   *  remote (host/owner/repo) when readable, else the cwd path basename. */
+  SUBJECT_KEY: "tangle.subject.key",
+  /** Normalized git remote (e.g. `github.com/tangle-network/agent-dev-container`). */
+  GIT_REPOSITORY: "git.repository",
+  /** Current branch at conversion time. */
+  GIT_BRANCH_NAME: "git.branch",
+  /** HEAD short sha at conversion time. */
+  GIT_COMMIT: "git.commit",
+  /** How traces resolved the session cwd: recorded cwd, repaired cwd, or span path. */
+  REPO_RESOLUTION_SOURCE: "traces.repo_resolution_source",
+  GIT_BRANCH: "tangle.git_branch",
+  HOST: "tangle.host",
+  /** Basename of the session file. (Renamed from the ambiguous `tangle.source`,
+   *  which collided with `tangle.ingest_source`.) */
+  SESSION_FILE: "tangle.session_file",
+  UPLOADED_AT: "tangle.uploaded_at",
+  UPLOADER: "tangle.uploader",
+  REDACTION_VERSION: "redaction.version",
+  REDACTION_COUNT: "redaction.count",
+  /** Upload contract: bounded root summary plus location-only receipt child spans.
+   *  Receipt hashes are deliberate integrity evidence; raw malformed bytes never upload. */
+  SESSION_INTEGRITY: "traces.session.integrity",
+  CORRUPTION_COUNT: "traces.session.corruption_count",
+  CORRUPTION_DIGEST: "traces.session.corruption_digest",
+  CORRUPTION_RECEIPT_VERSION: "traces.session.corruption.receipt_version",
+  CORRUPTION_RECEIPT_KIND: "traces.session.corruption.kind",
+  CORRUPTION_SOURCE_PATH: "traces.session.corruption.source_path",
+  CORRUPTION_LINE_NUMBER: "traces.session.corruption.line_number",
+  CORRUPTION_BYTE_OFFSET: "traces.session.corruption.byte_offset",
+  CORRUPTION_BYTE_LENGTH: "traces.session.corruption.byte_length",
+  CORRUPTION_SHA256: "traces.session.corruption.sha256",
+  RAW_SOURCE_RETENTION: "traces.session.raw_source_retention",
+  /** Container image reference the session executed in (OTel semconv key). */
+  CONTAINER_IMAGE: "container.image.name",
+  /** Immutable image digest (`sha256:…`) — the replay-grade environment pin. */
+  CONTAINER_IMAGE_DIGEST: "container.image.digest",
+  /** Sandbox/container instance id that executed the session. */
+  SANDBOX_ID: "tangle.sandbox.id",
+  /** Recorded execution cwd, verbatim. Unlike `tangle.cwd` it is never
+   *  repaired against the host filesystem — replay verification needs the
+   *  in-container path even when no such path exists on this host. */
+  ENVIRONMENT_CWD: "tangle.environment.cwd"
+};
+var INGEST_SOURCE_CLI = "cli";
+function environmentAttributes(environment) {
+  if (!environment) return {};
+  const attrs = {};
+  if (environment.image) attrs[ATTR.CONTAINER_IMAGE] = environment.image;
+  if (environment.imageDigest) attrs[ATTR.CONTAINER_IMAGE_DIGEST] = environment.imageDigest;
+  if (environment.sandboxId) attrs[ATTR.SANDBOX_ID] = environment.sandboxId;
+  if (environment.cwd) attrs[ATTR.ENVIRONMENT_CWD] = environment.cwd;
+  if (environment.gitCommit) attrs[ATTR.GIT_COMMIT] = environment.gitCommit;
+  return attrs;
+}
+function stampEnvironmentAttrs(spans, environment) {
+  const attrs = environmentAttributes(environment);
+  const keys = Object.keys(attrs);
+  if (keys.length === 0) return;
+  for (const span2 of spans) {
+    for (const key of keys) {
+      if (span2.attributes[key] === void 0) span2.attributes[key] = attrs[key];
+    }
+  }
+}
+function environmentFromSpanAttributes(spans) {
+  const first = (key) => {
+    for (const span2 of spans) {
+      const value = span2.attributes[key];
+      if (typeof value === "string" && value.length > 0) return value;
+    }
+    return void 0;
+  };
+  const image = first(ATTR.CONTAINER_IMAGE);
+  const imageDigest = first(ATTR.CONTAINER_IMAGE_DIGEST);
+  const sandboxId = first(ATTR.SANDBOX_ID);
+  const cwd = first(ATTR.ENVIRONMENT_CWD);
+  if (!image && !imageDigest && !sandboxId && !cwd) return null;
+  return {
+    ...image ? { image } : {},
+    ...imageDigest ? { imageDigest } : {},
+    ...sandboxId ? { sandboxId } : {},
+    cwd: cwd ?? null
+  };
+}
+var DEFAULT_HARNESS = "claude-code";
+var SESSION_ID_ATTRIBUTE_KEYS = [ATTR.SESSION_ID, "session.id", "traces.session.id"];
+function sessionIdFromAttributes(attributes2) {
+  return SESSION_ID_ATTRIBUTE_KEYS.map((key) => attributes2[key]).find(
+    (value) => typeof value === "string" && value.length > 0
+  );
+}
+function indexSessionIdsByTrace(spans) {
+  const candidatesByTrace = /* @__PURE__ */ new Map();
+  for (const span2 of spans) {
+    const candidates = candidatesByTrace.get(span2.trace_id) ?? /* @__PURE__ */ new Set();
+    for (const key of SESSION_ID_ATTRIBUTE_KEYS) {
+      const value = span2.attributes[key];
+      if (typeof value === "string" && value.length > 0) candidates.add(value);
+    }
+    if (candidates.size > 0) candidatesByTrace.set(span2.trace_id, candidates);
+  }
+  const sessionByTrace = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  for (const [traceId, candidates] of candidatesByTrace) {
+    const sessionIds = [...candidates].sort();
+    if (sessionIds.length === 1) {
+      sessionByTrace.set(traceId, sessionIds[0]);
+    } else {
+      conflicts.push({ traceId, sessionIds });
+    }
+  }
+  conflicts.sort((a, b) => a.traceId.localeCompare(b.traceId));
+  return { sessionByTrace, conflicts };
+}
+function stampSessionIdentity(spans, fallbackSessionId) {
+  const { sessionByTrace, conflicts } = indexSessionIdsByTrace(spans);
+  const conflictingTraceIds = new Set(conflicts.map((conflict) => conflict.traceId));
+  const traceIds = new Set(spans.map((span2) => span2.trace_id));
+  const singleTraceId = traceIds.size === 1 ? traceIds.values().next().value : void 0;
+  for (const span2 of spans) {
+    if (conflictingTraceIds.has(span2.trace_id)) continue;
+    const sessionId = sessionByTrace.get(span2.trace_id) ?? singleTraceId ?? fallbackSessionId;
+    if (!sessionIdFromAttributes(span2.attributes)) {
+      span2.attributes[ATTR.SESSION_ID] = sessionId;
+    }
+  }
+}
+
 // src/time.ts
 function parseIsoToEpochMs(ts) {
   if (typeof ts !== "string" || ts.trim().length === 0) {
@@ -31,7 +170,7 @@ function parseSince(value) {
 import { readdir, readFile, stat } from "fs/promises";
 import { basename, join } from "path";
 import {
-  ATTR,
+  ATTR as ATTR2,
   declaredSpanKind,
   resolveSpanKind,
   SPAN_KIND_ATTR_KEYS,
@@ -325,7 +464,7 @@ function readLinks(value, traceId) {
   return links;
 }
 function bridgeContractAttributes(attributes2) {
-  const toolName4 = nonEmptyString(attributes2[ATTR.toolName]);
+  const toolName4 = nonEmptyString(attributes2[ATTR2.toolName]);
   if (toolName4 !== null && nonEmptyString(attributes2[TOOL_NAME]) === null) {
     attributes2[TOOL_NAME] = toolName4;
   }
@@ -385,7 +524,7 @@ function otlpRowToSpan(row, fallbackTraceId) {
   bridgeContractAttributes(attributes2);
   const { kind, declaredRaw, substituted: kindSubstituted } = resolveRowKind(row, attributes2, name);
   if (kindSubstituted) substitute("kind", declaredRaw ?? void 0);
-  attributes2[ATTR.spanKind] = kind;
+  attributes2[ATTR2.spanKind] = kind;
   if (kind === "TOOL") Object.assign(attributes2, capturedToolIo(attributes2));
   const status = isObject(row.status) ? row.status : void 0;
   const statusMessage = nonEmptyString(status?.message);
@@ -725,6 +864,9 @@ function toOpenInferenceSpan(s) {
   for (const k of ["tangle.subject.key", "git.repository", "git.branch", "git.commit", "tangle.cwd", "traces.repo_resolution_source"]) {
     if (a[k] != null) resourceAttrs[k] = a[k];
   }
+  for (const k of ["container.image.name", "container.image.digest", "tangle.sandbox.id", "tangle.environment.cwd"]) {
+    if (a[k] != null) resourceAttrs[k] = a[k];
+  }
   for (const k of ["traces.source.unreadable_rows", "traces.source.unreadable_row_kinds"]) {
     if (a[k] != null) resourceAttrs[k] = a[k];
   }
@@ -764,11 +906,11 @@ function serializeSpans(spans) {
 `;
 }
 async function writeOtlpFile(spans, outPath) {
-  const { mkdtemp: mkdtemp8, writeFile: writeFile10 } = await import("fs/promises");
+  const { mkdtemp: mkdtemp8, writeFile: writeFile12 } = await import("fs/promises");
   const { tmpdir: tmpdir9 } = await import("os");
-  const { join: join34 } = await import("path");
-  const path = outPath ?? join34(await mkdtemp8(join34(tmpdir9(), "traces-")), "spans.otlp.jsonl");
-  await writeFile10(path, serializeSpans(spans), "utf8");
+  const { join: join36 } = await import("path");
+  const path = outPath ?? join36(await mkdtemp8(join36(tmpdir9(), "traces-")), "spans.otlp.jsonl");
+  await writeFile12(path, serializeSpans(spans), "utf8");
   return path;
 }
 
@@ -796,95 +938,6 @@ function userPromptSpan(o) {
   });
 }
 
-// src/attributes.ts
-var ATTR2 = {
-  /** = the trace/session id. Wire contract (dedup linkage). */
-  SESSION_ID: "tangle.sessionId",
-  /** "cli" marks a CLI upload so the platform can drop a re-upload of a session
-   *  that also streamed live. Wire contract. */
-  INGEST_SOURCE: "tangle.ingest_source",
-  HARNESS: "tangle.harness",
-  CWD: "tangle.cwd",
-  /** THE per-session grouping key the spine derives subjects from
-   *  (`deriveSubjectKey` reads `tangle.subject.key` first). Resolves to the git
-   *  remote (host/owner/repo) when readable, else the cwd path basename. */
-  SUBJECT_KEY: "tangle.subject.key",
-  /** Normalized git remote (e.g. `github.com/tangle-network/agent-dev-container`). */
-  GIT_REPOSITORY: "git.repository",
-  /** Current branch at conversion time. */
-  GIT_BRANCH_NAME: "git.branch",
-  /** HEAD short sha at conversion time. */
-  GIT_COMMIT: "git.commit",
-  /** How traces resolved the session cwd: recorded cwd, repaired cwd, or span path. */
-  REPO_RESOLUTION_SOURCE: "traces.repo_resolution_source",
-  GIT_BRANCH: "tangle.git_branch",
-  HOST: "tangle.host",
-  /** Basename of the session file. (Renamed from the ambiguous `tangle.source`,
-   *  which collided with `tangle.ingest_source`.) */
-  SESSION_FILE: "tangle.session_file",
-  UPLOADED_AT: "tangle.uploaded_at",
-  UPLOADER: "tangle.uploader",
-  REDACTION_VERSION: "redaction.version",
-  REDACTION_COUNT: "redaction.count",
-  /** Upload contract: bounded root summary plus location-only receipt child spans.
-   *  Receipt hashes are deliberate integrity evidence; raw malformed bytes never upload. */
-  SESSION_INTEGRITY: "traces.session.integrity",
-  CORRUPTION_COUNT: "traces.session.corruption_count",
-  CORRUPTION_DIGEST: "traces.session.corruption_digest",
-  CORRUPTION_RECEIPT_VERSION: "traces.session.corruption.receipt_version",
-  CORRUPTION_RECEIPT_KIND: "traces.session.corruption.kind",
-  CORRUPTION_SOURCE_PATH: "traces.session.corruption.source_path",
-  CORRUPTION_LINE_NUMBER: "traces.session.corruption.line_number",
-  CORRUPTION_BYTE_OFFSET: "traces.session.corruption.byte_offset",
-  CORRUPTION_BYTE_LENGTH: "traces.session.corruption.byte_length",
-  CORRUPTION_SHA256: "traces.session.corruption.sha256",
-  RAW_SOURCE_RETENTION: "traces.session.raw_source_retention"
-};
-var INGEST_SOURCE_CLI = "cli";
-var DEFAULT_HARNESS = "claude-code";
-var SESSION_ID_ATTRIBUTE_KEYS = [ATTR2.SESSION_ID, "session.id", "traces.session.id"];
-function sessionIdFromAttributes(attributes2) {
-  return SESSION_ID_ATTRIBUTE_KEYS.map((key) => attributes2[key]).find(
-    (value) => typeof value === "string" && value.length > 0
-  );
-}
-function indexSessionIdsByTrace(spans) {
-  const candidatesByTrace = /* @__PURE__ */ new Map();
-  for (const span2 of spans) {
-    const candidates = candidatesByTrace.get(span2.trace_id) ?? /* @__PURE__ */ new Set();
-    for (const key of SESSION_ID_ATTRIBUTE_KEYS) {
-      const value = span2.attributes[key];
-      if (typeof value === "string" && value.length > 0) candidates.add(value);
-    }
-    if (candidates.size > 0) candidatesByTrace.set(span2.trace_id, candidates);
-  }
-  const sessionByTrace = /* @__PURE__ */ new Map();
-  const conflicts = [];
-  for (const [traceId, candidates] of candidatesByTrace) {
-    const sessionIds = [...candidates].sort();
-    if (sessionIds.length === 1) {
-      sessionByTrace.set(traceId, sessionIds[0]);
-    } else {
-      conflicts.push({ traceId, sessionIds });
-    }
-  }
-  conflicts.sort((a, b) => a.traceId.localeCompare(b.traceId));
-  return { sessionByTrace, conflicts };
-}
-function stampSessionIdentity(spans, fallbackSessionId) {
-  const { sessionByTrace, conflicts } = indexSessionIdsByTrace(spans);
-  const conflictingTraceIds = new Set(conflicts.map((conflict) => conflict.traceId));
-  const traceIds = new Set(spans.map((span2) => span2.trace_id));
-  const singleTraceId = traceIds.size === 1 ? traceIds.values().next().value : void 0;
-  for (const span2 of spans) {
-    if (conflictingTraceIds.has(span2.trace_id)) continue;
-    const sessionId = sessionByTrace.get(span2.trace_id) ?? singleTraceId ?? fallbackSessionId;
-    if (!sessionIdFromAttributes(span2.attributes)) {
-      span2.attributes[ATTR2.SESSION_ID] = sessionId;
-    }
-  }
-}
-
 // src/chat-trajectory.ts
 import { createHash as createHash3 } from "crypto";
 function isChatTrajectoryMessage(value) {
@@ -1907,10 +1960,10 @@ function sessionJsonlOptions(ref, options = {}) {
 function sessionIntegrityAttributes(ref) {
   if (!ref.integrity) return {};
   return {
-    [ATTR2.SESSION_INTEGRITY]: ref.integrity.status,
-    [ATTR2.CORRUPTION_COUNT]: ref.integrity.corruptions.length,
-    [ATTR2.CORRUPTION_DIGEST]: corruptionDigest(ref.integrity.corruptions),
-    [ATTR2.RAW_SOURCE_RETENTION]: "local_source_only"
+    [ATTR.SESSION_INTEGRITY]: ref.integrity.status,
+    [ATTR.CORRUPTION_COUNT]: ref.integrity.corruptions.length,
+    [ATTR.CORRUPTION_DIGEST]: corruptionDigest(ref.integrity.corruptions),
+    [ATTR.RAW_SOURCE_RETENTION]: "local_source_only"
   };
 }
 function corruptionDigest(receipts) {
@@ -1951,15 +2004,15 @@ function stampSessionIntegrity(ref, spans) {
       status: "ERROR",
       service: typeof parent.attributes["service.name"] === "string" ? parent.attributes["service.name"] : ref.harness,
       extra: {
-        [ATTR2.SESSION_INTEGRITY]: ref.integrity.status,
-        [ATTR2.CORRUPTION_RECEIPT_VERSION]: receipt.receiptVersion,
-        [ATTR2.CORRUPTION_RECEIPT_KIND]: receipt.kind,
-        [ATTR2.CORRUPTION_SOURCE_PATH]: receipt.sourcePath,
-        [ATTR2.CORRUPTION_LINE_NUMBER]: receipt.lineNumber,
-        [ATTR2.CORRUPTION_BYTE_OFFSET]: receipt.byteOffset,
-        [ATTR2.CORRUPTION_BYTE_LENGTH]: receipt.byteLength,
-        [ATTR2.CORRUPTION_SHA256]: receipt.sha256,
-        [ATTR2.RAW_SOURCE_RETENTION]: "local_source_only"
+        [ATTR.SESSION_INTEGRITY]: ref.integrity.status,
+        [ATTR.CORRUPTION_RECEIPT_VERSION]: receipt.receiptVersion,
+        [ATTR.CORRUPTION_RECEIPT_KIND]: receipt.kind,
+        [ATTR.CORRUPTION_SOURCE_PATH]: receipt.sourcePath,
+        [ATTR.CORRUPTION_LINE_NUMBER]: receipt.lineNumber,
+        [ATTR.CORRUPTION_BYTE_OFFSET]: receipt.byteOffset,
+        [ATTR.CORRUPTION_BYTE_LENGTH]: receipt.byteLength,
+        [ATTR.CORRUPTION_SHA256]: receipt.sha256,
+        [ATTR.RAW_SOURCE_RETENTION]: "local_source_only"
       }
     }));
     existingSpanIds.add(spanId);
@@ -6236,7 +6289,7 @@ function extractAbsolutePaths(spans) {
 }
 async function resolveRepoAttrs(cwd) {
   if (!cwd) return {};
-  const attrs = { [ATTR2.CWD]: cwd };
+  const attrs = { [ATTR.CWD]: cwd };
   const basename16 = (() => {
     const trimmed = cwd.replace(/\/+$/g, "");
     const idx = trimmed.lastIndexOf("/");
@@ -6249,17 +6302,17 @@ async function resolveRepoAttrs(cwd) {
     const { remote, branch, commit } = await readGit(gitRoot);
     const normalized = remote ? normalizeRemote(remote) : null;
     if (normalized) {
-      attrs[ATTR2.SUBJECT_KEY] = normalized;
-      attrs[ATTR2.GIT_REPOSITORY] = normalized;
-      if (branch) attrs[ATTR2.GIT_BRANCH_NAME] = branch;
-      if (commit) attrs[ATTR2.GIT_COMMIT] = commit;
+      attrs[ATTR.SUBJECT_KEY] = normalized;
+      attrs[ATTR.GIT_REPOSITORY] = normalized;
+      if (branch) attrs[ATTR.GIT_BRANCH_NAME] = branch;
+      if (commit) attrs[ATTR.GIT_COMMIT] = commit;
       return attrs;
     }
-    if (branch) attrs[ATTR2.GIT_BRANCH_NAME] = branch;
-    if (commit) attrs[ATTR2.GIT_COMMIT] = commit;
+    if (branch) attrs[ATTR.GIT_BRANCH_NAME] = branch;
+    if (commit) attrs[ATTR.GIT_COMMIT] = commit;
   } catch {
   }
-  attrs[ATTR2.SUBJECT_KEY] = basename16;
+  attrs[ATTR.SUBJECT_KEY] = basename16;
   return attrs;
 }
 async function repoCandidateForPath(path) {
@@ -6290,12 +6343,12 @@ async function resolveSessionRepoAttrs(cwd, spans) {
     resolved.push({ ...candidate, attrs });
   }
   const byScore = (a, b) => b.score - a.score || a.order - b.order;
-  const withGit = resolved.filter((candidate) => candidate.attrs[ATTR2.GIT_REPOSITORY]).sort(byScore);
-  const selected = withGit[0] ?? resolved.filter((candidate) => candidate.attrs[ATTR2.SUBJECT_KEY]).sort(byScore)[0];
+  const withGit = resolved.filter((candidate) => candidate.attrs[ATTR.GIT_REPOSITORY]).sort(byScore);
+  const selected = withGit[0] ?? resolved.filter((candidate) => candidate.attrs[ATTR.SUBJECT_KEY]).sort(byScore)[0];
   if (!selected) return { attrs: {}, cwd: null, source: "none" };
   return {
-    attrs: { ...selected.attrs, [ATTR2.REPO_RESOLUTION_SOURCE]: selected.source },
-    cwd: selected.attrs[ATTR2.CWD] ?? selected.cwd,
+    attrs: { ...selected.attrs, [ATTR.REPO_RESOLUTION_SOURCE]: selected.source },
+    cwd: selected.attrs[ATTR.CWD] ?? selected.cwd,
     source: selected.source
   };
 }
@@ -6323,9 +6376,9 @@ async function resolutionForWorkdirEvidence(evidence3, cache) {
     return null;
   }
   const attrs = await resolveRepoAttrs(cwd);
-  const resolved = attrs[ATTR2.SUBJECT_KEY] ? {
-    attrs: { ...attrs, [ATTR2.REPO_RESOLUTION_SOURCE]: evidence3.source },
-    cwd: attrs[ATTR2.CWD] ?? cwd,
+  const resolved = attrs[ATTR.SUBJECT_KEY] ? {
+    attrs: { ...attrs, [ATTR.REPO_RESOLUTION_SOURCE]: evidence3.source },
+    cwd: attrs[ATTR.CWD] ?? cwd,
     source: evidence3.source
   } : null;
   cache.set(evidence3.path, resolved);
@@ -6348,7 +6401,7 @@ async function resolveSpanWorkdirRepoAttrs(span2, cache) {
   }
   const byScore = (a, b) => b.score - a.score || a.order - b.order;
   const resolved = [...candidates.values()];
-  const selected = resolved.filter((candidate) => candidate.repo.attrs[ATTR2.GIT_REPOSITORY]).sort(byScore)[0] ?? resolved.filter((candidate) => candidate.repo.attrs[ATTR2.SUBJECT_KEY]).sort(byScore)[0];
+  const selected = resolved.filter((candidate) => candidate.repo.attrs[ATTR.GIT_REPOSITORY]).sort(byScore)[0] ?? resolved.filter((candidate) => candidate.repo.attrs[ATTR.SUBJECT_KEY]).sort(byScore)[0];
   if (!selected) return null;
   return selected.repo;
 }
@@ -6364,7 +6417,7 @@ async function stampSpanWorkdirRepoAttrs(spans) {
 async function awaitWithAbort(operation, signal) {
   if (!signal) return operation;
   signal.throwIfAborted();
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve10, reject) => {
     const stop = () => {
       signal.removeEventListener("abort", stop);
       reject(signal.reason);
@@ -6373,7 +6426,7 @@ async function awaitWithAbort(operation, signal) {
     operation.then(
       (value) => {
         signal.removeEventListener("abort", stop);
-        resolve8(value);
+        resolve10(value);
       },
       (error) => {
         signal.removeEventListener("abort", stop);
@@ -6392,6 +6445,8 @@ async function parseSession(adapter, ref, options = {}) {
   if (spans.length === 0) throw new EmptySessionError(ref.path);
   stampSessionIntegrity(ref, spans);
   stampSessionIdentity(spans, ref.sessionId);
+  stampEnvironmentAttrs(spans, ref.environment);
+  if (ref.cwd === null && ref.environment?.cwd) ref.cwd = ref.environment.cwd;
   const repo = await resolveSessionRepoAttrs(ref.cwd, spans);
   if (repo.cwd) ref.cwd = repo.cwd;
   stampRepoAttrs(spans, repo.attrs);
@@ -6553,6 +6608,7 @@ import {
   OPENINFERENCE_SPAN_KIND as OPENINFERENCE_SPAN_KIND2,
   TOOL_NAME as TOOL_NAME3
 } from "@tangle-network/agent-eval/trace-attributes";
+var POLICY_EVIDENCE_NOTE = "This is normalized coding-agent session evidence for downstream policy mining; it is not an eval campaign cell.";
 function stringAttr(span2, key) {
   const value = span2.attributes[key];
   return typeof value === "string" && value.length > 0 ? value : void 0;
@@ -6563,12 +6619,12 @@ function spanKind(span2) {
 function repoFromSpans(spans) {
   const attrs = {};
   for (const span2 of spans) {
-    attrs.subjectKey ??= stringAttr(span2, ATTR2.SUBJECT_KEY);
-    attrs.repository ??= stringAttr(span2, ATTR2.GIT_REPOSITORY);
-    attrs.branch ??= stringAttr(span2, ATTR2.GIT_BRANCH_NAME);
-    attrs.commit ??= stringAttr(span2, ATTR2.GIT_COMMIT);
-    attrs.cwd ??= stringAttr(span2, ATTR2.CWD);
-    attrs.resolutionSource ??= stringAttr(span2, ATTR2.REPO_RESOLUTION_SOURCE);
+    attrs.subjectKey ??= stringAttr(span2, ATTR.SUBJECT_KEY);
+    attrs.repository ??= stringAttr(span2, ATTR.GIT_REPOSITORY);
+    attrs.branch ??= stringAttr(span2, ATTR.GIT_BRANCH_NAME);
+    attrs.commit ??= stringAttr(span2, ATTR.GIT_COMMIT);
+    attrs.cwd ??= stringAttr(span2, ATTR.CWD);
+    attrs.resolutionSource ??= stringAttr(span2, ATTR.REPO_RESOLUTION_SOURCE);
     if (attrs.subjectKey && attrs.repository && attrs.branch && attrs.commit && attrs.cwd && attrs.resolutionSource) break;
   }
   return attrs;
@@ -6657,7 +6713,7 @@ async function buildPolicyEvidenceRecord(ref, spans, opts = {}) {
       ...opts.otlpPath ? { otlpPath: opts.otlpPath } : {},
       ...opts.sourceSha256 ? { sourceSha256: opts.sourceSha256 } : {},
       notCampaignCell: true,
-      note: "This is normalized coding-agent session evidence for downstream policy mining; it is not an eval campaign cell."
+      note: POLICY_EVIDENCE_NOTE
     }
   };
 }
@@ -7181,11 +7237,11 @@ function parseCorpusFlag(value) {
   if (eq <= 0) throw new Error(`--corpus must be name=<labels>::<prepared>, got: ${value}`);
   const name = value.slice(0, eq);
   const rest = value.slice(eq + 1);
-  const sep2 = rest.indexOf("::");
-  if (sep2 <= 0 || sep2 === rest.length - 2) {
+  const sep3 = rest.indexOf("::");
+  if (sep3 <= 0 || sep3 === rest.length - 2) {
     throw new Error(`--corpus must be name=<labels>::<prepared>, got: ${value}`);
   }
-  return { name, labelsPath: rest.slice(0, sep2), preparedDir: rest.slice(sep2 + 2) };
+  return { name, labelsPath: rest.slice(0, sep3), preparedDir: rest.slice(sep3 + 2) };
 }
 var SUBMIT_ACTION_SIGNATURE = "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT";
 function isSubmitAction(action) {
@@ -7211,7 +7267,7 @@ function goldIncorrectSteps(entry) {
 function findRawTrajFiles(sweRawDir) {
   if (!existsSync2(sweRawDir)) return [];
   const entries = readdirSync2(sweRawDir, { recursive: true, encoding: "utf8" });
-  return entries.filter((relative5) => relative5.endsWith(".traj.json")).map((relative5) => join20(sweRawDir, relative5)).sort();
+  return entries.filter((relative6) => relative6.endsWith(".traj.json")).map((relative6) => join20(sweRawDir, relative6)).sort();
 }
 function cwdFromPwdObservation(steps) {
   for (const step of steps) {
@@ -8376,9 +8432,9 @@ function renderBatchReport(report) {
     lines.push("");
     lines.push("| corpus | trajectory | image | error |");
     lines.push("| --- | --- | --- | --- |");
-    for (const failure of report.pullFailures) {
+    for (const failure2 of report.pullFailures) {
       lines.push(
-        `| ${failure.corpus} | ${failure.trajId} | \`${failure.image}\` | ${failure.error.replaceAll("|", "\\|")} |`
+        `| ${failure2.corpus} | ${failure2.trajId} | \`${failure2.image}\` | ${failure2.error.replaceAll("|", "\\|")} |`
       );
     }
   }
@@ -9444,13 +9500,13 @@ function terminateWindowsProcessTree(child) {
     forceKill(child);
     return Promise.resolve();
   }
-  return new Promise((resolve8) => {
+  return new Promise((resolve10) => {
     let finished = false;
     const finish = () => {
       if (finished) return;
       finished = true;
       forceKill(child);
-      resolve8();
+      resolve10();
     };
     let killer;
     try {
@@ -9477,7 +9533,7 @@ function signalProcess(pid, signal) {
   }
 }
 function readProcessTableWithPs() {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve10, reject) => {
     let child;
     try {
       child = spawn("ps", ["-A", "-o", "pid=", "-o", "ppid="], {
@@ -9531,7 +9587,7 @@ function readProcessTableWithPs() {
           reject(new Error("ps: returned no process records"));
           return;
         }
-        resolve8(rows);
+        resolve10(rows);
       });
     });
   });
@@ -9541,10 +9597,10 @@ async function readLinuxProcProcessTable() {
   const rows = await Promise.all(
     entries.filter((entry) => entry.isDirectory() && /^\d+$/.test(entry.name)).map(async (entry) => {
       try {
-        const stat17 = await readFile7(`/proc/${entry.name}/stat`, "utf8");
-        const commandEnd = stat17.lastIndexOf(")");
+        const stat18 = await readFile7(`/proc/${entry.name}/stat`, "utf8");
+        const commandEnd = stat18.lastIndexOf(")");
         if (commandEnd < 0) return void 0;
-        const fields = stat17.slice(commandEnd + 1).trim().split(/\s+/);
+        const fields = stat18.slice(commandEnd + 1).trim().split(/\s+/);
         const pid = Number(entry.name);
         const parentPid = Number(fields[1]);
         if (!Number.isSafeInteger(pid) || pid < 1 || !Number.isSafeInteger(parentPid) || parentPid < 0) {
@@ -9606,7 +9662,7 @@ async function terminatePosixProcessTree(child) {
   }
   const rootPid = child.pid;
   const descendants = /* @__PURE__ */ new Map();
-  let failure;
+  let failure2;
   try {
     signalProcess(-rootPid, "SIGSTOP");
     signalProcess(rootPid, "SIGSTOP");
@@ -9623,7 +9679,7 @@ async function terminatePosixProcessTree(child) {
       previous = signature;
     }
   } catch (error) {
-    failure = error;
+    failure2 = error;
   } finally {
     for (const processEntry of [...descendants.values()].sort(
       (left, right) => right.depth - left.depth
@@ -9631,18 +9687,18 @@ async function terminatePosixProcessTree(child) {
       try {
         signalProcess(processEntry.pid, "SIGKILL");
       } catch (error) {
-        failure ??= error;
+        failure2 ??= error;
       }
     }
     try {
       signalProcess(-rootPid, "SIGKILL");
     } catch (error) {
-      failure ??= error;
+      failure2 ??= error;
     }
     forceKill(child);
   }
-  if (failure) {
-    throw failure instanceof Error ? failure : new Error(String(failure));
+  if (failure2) {
+    throw failure2 instanceof Error ? failure2 : new Error(String(failure2));
   }
 }
 function terminateProcessTree(child) {
@@ -9666,7 +9722,7 @@ function runCommand(command, args = [], opts = {}) {
     throw new RangeError("maxBuffer must be a positive safe integer");
   }
   if (opts.signal?.aborted) return Promise.reject(abortError(opts.signal));
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve10, reject) => {
     let child;
     try {
       child = spawn(command, [...args], { detached: process.platform !== "win32" });
@@ -9698,7 +9754,7 @@ function runCommand(command, args = [], opts = {}) {
       } else if (spawnError) {
         reject(spawnError);
       } else {
-        resolve8({ stdout: out, stderr: err, code: closeCode });
+        resolve10({ stdout: out, stderr: err, code: closeCode });
       }
     };
     function requestTermination(error) {
@@ -10613,71 +10669,490 @@ function assertPositiveInteger(name, value) {
   }
 }
 
-// src/redact.ts
-import { DEFAULT_REDACTION_RULES, redactValue } from "@tangle-network/agent-eval/traces";
-var CODING_REDACTION_RULES = [
-  { id: "github-token", pattern: /\b(?:gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{22,})\b/g },
-  { id: "aws-akid", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
-  { id: "slack-token", pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g },
-  { id: "jwt", pattern: /\beyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g },
-  { id: "bearer", pattern: /\bBearer\s+[A-Za-z0-9._-]{16,}/gi },
-  {
-    id: "private-key",
-    pattern: /-----BEGIN(?:[A-Z ]+)?PRIVATE KEY-----[\s\S]*?-----END(?:[A-Z ]+)?PRIVATE KEY-----/g
-  },
-  // Match the whole identifier because underscores prevent a word boundary before a secret suffix.
-  {
-    id: "assigned-secret",
-    pattern: /(?<![A-Za-z0-9_-])(?:[A-Za-z_][A-Za-z0-9_-]*)?(?:api[_-]?key|secret|token|password|passwd|access[_-]?token|client[_-]?secret)(?![A-Za-z0-9_-])\+?=(?:\$\((?:\\.|[^\\\r\n])*\)|\$\{(?:\\.|[^}\\\r\n])*\}|`(?:\\.|[^`\\\r\n])*`|\$?'(?:\\.|[^'\\\r\n])*'|\$?"(?:\\.|[^"\\\r\n])*"|\\[^\r\n]|[^\s;&|<>()"'`\\\r\n])+/gi
-  },
-  // Config-file secrets (YAML/INI line keys, JSON quoted keys) — the coverage the shell
-  // rule above deliberately gave up to spare prose ("Narrative token: x") and type
-  // annotations ("(token: string)"). The line anchor is the discriminator: config keys
-  // start their line, prose colons never do; JSON keys are safe anywhere because both
-  // sides are quoted. Identifiers must END in a secret word, same as the shell rule.
-  {
-    id: "config-secret",
-    pattern: /(?:^[ \t]*["']?(?:[A-Za-z_][A-Za-z0-9_-]*)?(?:api[_-]?key|secret|token|password|passwd|access[_-]?token|client[_-]?secret)(?![A-Za-z0-9_-])["']?[ \t]*[:=][ \t]*|["'](?:[A-Za-z_][A-Za-z0-9_-]*)?(?:api[_-]?key|secret|token|password|passwd|access[_-]?token|client[_-]?secret)["']\s*:\s*)["']?[A-Za-z0-9._\-]{12,}["']?/gim
-  },
-  // Credentials embedded in URLs — common when a prompt pastes a curl/clone line.
-  { id: "url-userinfo", pattern: /\b[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]+@/gi },
-  {
-    id: "url-secret-param",
-    pattern: /[?&](?:access[_-]?token|api[_-]?key|apikey|auth|token|secret|password|sig|signature)=[^&\s"'#)]+/gi
+// src/analyst-engine-prime.ts
+import { createHash as createHash10 } from "crypto";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+var DEFAULT_BRIDGE_URL = "http://localhost:4181";
+var DEFAULT_MODEL = "prime/zai/glm-5.2";
+var DEFAULT_TIMEOUT_MS = 12e5;
+var DEFAULT_MAX_INLINE_CHARS = 36e4;
+var DEFAULT_PER_ATTRIBUTE_CHAR_CAP = 1200;
+var DEFAULT_QUESTION = "Diagnose this trajectory: identify concrete agent failures, wasted work, and unsupported claims.";
+var MAX_FINDINGS = 10;
+var MAX_SPAN_IDS_PER_FINDING = 8;
+var SEVERITIES = /* @__PURE__ */ new Set(["critical", "high", "medium", "low", "info"]);
+var ANALYST_ID = "prime";
+function positiveIntegerEnv(name) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return void 0;
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new TypeError(`${name} must be a positive integer, got '${raw}'`);
   }
-];
-var TRACES_REDACTION_RULES = [...DEFAULT_REDACTION_RULES, ...CODING_REDACTION_RULES];
-function redactSpans(spans, rules = TRACES_REDACTION_RULES) {
-  const report = { redactionCount: 0, byRule: {} };
-  const out = spans.map((s) => {
-    const attributes2 = redactValue(s.attributes, rules, report).value;
-    normalizeToolIoAttributes(attributes2);
-    let status = s.status;
-    if (status.message) {
-      const m = redactValue(status.message, rules, report).value;
-      if (typeof m === "string" && m !== status.message) status = { ...status, message: m };
-    }
-    return { ...s, attributes: attributes2, status };
-  });
-  return { spans: out, report };
+  return value;
 }
-async function applyRedactor(spans, redactor) {
-  const capturedKeys = ["content", ...TOOL_IO_VALUE_KEYS];
-  const fields = [];
-  const texts = [];
-  spans.forEach((s, i) => {
-    for (const key of capturedKeys) {
-      const value = s.attributes[key];
-      if (typeof value === "string" && value.length > 0) {
-        fields.push({ spanIndex: i, key });
-        texts.push(value);
-      }
-    }
-    if (s.status.message) {
-      fields.push({ spanIndex: i, key: "status.message" });
-      texts.push(s.status.message);
-    }
-  });
+function finiteOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function normalizeUsage(raw) {
+  if (!raw || typeof raw !== "object") return { calls: null, tokens: null, estimated: false };
+  const usage = raw;
+  const input = finiteOrNull(usage.prompt_tokens);
+  const output = finiteOrNull(usage.completion_tokens);
+  return {
+    calls: finiteOrNull(usage.model_requests),
+    tokens: input === null && output === null ? null : { input, output },
+    estimated: usage.estimated === true
+  };
+}
+function mergeUsage(a, b) {
+  const calls = a.calls !== null && b.calls !== null ? a.calls + b.calls : null;
+  const tokens3 = a.tokens !== null && b.tokens !== null && a.tokens.input !== null && b.tokens.input !== null && a.tokens.output !== null && b.tokens.output !== null ? { input: a.tokens.input + b.tokens.input, output: a.tokens.output + b.tokens.output } : null;
+  return { calls, tokens: tokens3, estimated: a.estimated || b.estimated };
+}
+function renderUsage(usage) {
+  const calls = usage.calls === null ? "uncaptured" : String(usage.calls);
+  const input = usage.tokens?.input ?? "uncaptured";
+  const output = usage.tokens?.output ?? "uncaptured";
+  const estimated = usage.estimated ? " (bridge-estimated)" : "";
+  return `usage: calls=${calls} input_tokens=${input} output_tokens=${output}${estimated}; cost=uncaptured (no pricing table)`;
+}
+function capAttributeValue(value, cap) {
+  const rendered = JSON.stringify(value);
+  if (rendered === void 0 || rendered.length <= cap) return value;
+  if (typeof value === "string") return `${value.slice(0, cap)}\u2026[truncated ${value.length - cap} chars]`;
+  return `[omitted non-string attribute: ${rendered.length} JSON chars]`;
+}
+function capRowAttributes(row, cap) {
+  const attributes2 = row.attributes;
+  if (!attributes2 || typeof attributes2 !== "object" || Array.isArray(attributes2)) return row;
+  const capped = {};
+  for (const [key, value] of Object.entries(attributes2)) {
+    capped[key] = capAttributeValue(value, cap);
+  }
+  return { ...row, attributes: capped };
+}
+async function projectArtifact(otlpPath, maxInlineChars, perAttributeCharCap, signal) {
+  const rows = [];
+  const spanTraces = /* @__PURE__ */ new Map();
+  let index = 0;
+  for await (const value of readJsonl(otlpPath, { signal })) {
+    const label = `${otlpPath}:${index + 1}`;
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      throw new TypeError(`${label} must contain an object`);
+    }
+    const row = value;
+    if (typeof row.trace_id !== "string" || row.trace_id.length === 0) {
+      throw new TypeError(`${label}.trace_id must be a non-empty string`);
+    }
+    if (typeof row.span_id !== "string" || row.span_id.length === 0) {
+      throw new TypeError(`${label}.span_id must be a non-empty string`);
+    }
+    rows.push(row);
+    const traces = spanTraces.get(row.span_id) ?? /* @__PURE__ */ new Set();
+    traces.add(row.trace_id);
+    spanTraces.set(row.span_id, traces);
+    index += 1;
+  }
+  if (rows.length === 0) throw new Error(`${otlpPath} contains no spans`);
+  const traceCount = new Set(rows.map((row) => row.trace_id)).size;
+  let projected = rows;
+  let rendered = JSON.stringify(projected);
+  const delivery = {
+    mode: "inline-json",
+    perAttributeCharCap: null,
+    renderedChars: rendered.length
+  };
+  if (rendered.length > maxInlineChars) {
+    projected = rows.map((row) => capRowAttributes(row, perAttributeCharCap));
+    rendered = JSON.stringify(projected);
+    delivery.perAttributeCharCap = perAttributeCharCap;
+    delivery.renderedChars = rendered.length;
+  }
+  if (rendered.length > maxInlineChars) {
+    throw new Error(
+      `trajectory renders to ${rendered.length} chars even at per-attribute cap ${perAttributeCharCap} (budget ${maxInlineChars}); inline delivery impossible`
+    );
+  }
+  return { rows: projected, rendered, delivery, traceCount, spanTraces };
+}
+var OUTPUT_CONTRACT_LINES = [
+  "OUTPUT CONTRACT (you have no trace tools and no REPL):",
+  "You are a one-shot analyst. Every fact you need is in the TRAJECTORY JSON below.",
+  "Do not run shell commands, do not read or write files, do not use any tools.",
+  "Reply with EXACTLY one fenced ```json code block and no other fenced block. The JSON object has exactly two fields:",
+  '  "answer": string \u2014 ONE short sentence (max 300 chars) summarizing your verdict.',
+  '  "findings": array (possibly empty) of finding rows, each exactly:',
+  '    {"span_ids": [string, ...],',
+  '     "severity": "critical"|"high"|"medium"|"low"|"info",',
+  '     "area": string (short kebab-case topic, max 40 chars),',
+  '     "claim": string (ONE short sentence, max 200 chars),',
+  '     "action": string (optional, ONE short imperative sentence, max 200 chars),',
+  '     "confidence": number 0..1}',
+  "Do NOT include a rationale field. Keep every string SHORT \u2014 long strings get corrupted in transport and void your work.",
+  `Report at most ${MAX_FINDINGS} findings; a finding cites 1..${MAX_SPAN_IDS_PER_FINDING} span_ids, each copied VERBATIM from a span in the trajectory below.`,
+  '"findings" is [] only for a clean trajectory.'
+];
+function buildPrompt(question, projection) {
+  return [
+    `QUESTION: ${question}`,
+    "",
+    ...OUTPUT_CONTRACT_LINES,
+    "",
+    `TRAJECTORY (${projection.traceCount} trace(s); ${projection.rows.length} spans; full OpenInference span projection as JSON):`,
+    projection.rendered
+  ].join("\n");
+}
+function buildRepairPrompt(parseDefect, previousReply) {
+  return [
+    "Your previous reply to a trace-analysis task was structurally malformed and could not be parsed",
+    `(${parseDefect}). Below is your previous reply verbatim. Re-emit ONLY the corrected JSON \u2014 one`,
+    "fenced ```json block, no other text, no tools. The JSON object has exactly two fields:",
+    '  "answer": string (ONE short sentence, max 300 chars)',
+    '  "findings": array (possibly empty) of {"span_ids": [string, ...],',
+    '   "severity": "critical"|"high"|"medium"|"low"|"info", "area": string (max 40 chars),',
+    '   "claim": string (max 200 chars), "action": string (optional, max 200 chars), "confidence": number 0..1}',
+    "No rationale field. Keep every string SHORT. Preserve the span ids and verdicts of your previous reply exactly; shorten prose freely.",
+    "",
+    "PREVIOUS REPLY:",
+    previousReply
+  ].join("\n");
+}
+function tryParseObject(text2) {
+  try {
+    const value = JSON.parse(text2.trim());
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function extractJsonObject(text2) {
+  const direct = tryParseObject(text2);
+  if (direct) return direct;
+  const fenced = [...text2.matchAll(/```(?:json)?\s*\n?([\s\S]*?)```/g)];
+  for (let i = fenced.length - 1; i >= 0; i -= 1) {
+    const candidate = tryParseObject(fenced[i][1]);
+    if (candidate) return candidate;
+  }
+  const start = text2.indexOf("{");
+  const end = text2.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    const candidate = tryParseObject(text2.slice(start, end + 1));
+    if (candidate) return candidate;
+  }
+  return null;
+}
+function parseDefectOf(parsed) {
+  if (parsed === null) return "no parseable JSON object";
+  if (!Array.isArray(parsed.findings)) return 'JSON has no "findings" array';
+  return null;
+}
+function findingRowDefect(row, spanTraces) {
+  if (!row || typeof row !== "object" || Array.isArray(row)) return "row is not an object";
+  const record2 = row;
+  if (!Array.isArray(record2.span_ids) || record2.span_ids.length === 0) {
+    return "span_ids must be a non-empty array";
+  }
+  const spanIds = [];
+  for (const id of record2.span_ids) {
+    if (typeof id !== "string" || id.length === 0) return "span_ids must contain non-empty strings";
+    const traces = spanTraces.get(id);
+    if (!traces) return `span_id '${id}' is not in the trajectory`;
+    if (traces.size > 1) return `span_id '${id}' is ambiguous across ${traces.size} traces`;
+    if (!spanIds.includes(id)) spanIds.push(id);
+  }
+  if (spanIds.length > MAX_SPAN_IDS_PER_FINDING) {
+    return `span_ids cites ${spanIds.length} distinct spans (cap ${MAX_SPAN_IDS_PER_FINDING})`;
+  }
+  if (typeof record2.severity !== "string" || !SEVERITIES.has(record2.severity)) {
+    return "severity outside the analyst severity enum";
+  }
+  if (typeof record2.area !== "string" || record2.area.trim().length === 0 || record2.area.length > 200) {
+    return "area must be a 1-200 char string";
+  }
+  if (typeof record2.claim !== "string" || record2.claim.trim().length === 0 || record2.claim.length > 2e3) {
+    return "claim must be a 1-2000 char string";
+  }
+  if (record2.action !== void 0 && (typeof record2.action !== "string" || record2.action.trim().length === 0 || record2.action.length > 2e3)) {
+    return "action must be a 1-2000 char string when present";
+  }
+  if (typeof record2.confidence !== "number" || !Number.isFinite(record2.confidence) || record2.confidence < 0 || record2.confidence > 1) {
+    return "confidence must be 0..1";
+  }
+  return {
+    spanIds,
+    severity: record2.severity,
+    area: record2.area.trim(),
+    claim: record2.claim.trim(),
+    ...typeof record2.action === "string" ? { action: record2.action.trim() } : {},
+    confidence: record2.confidence
+  };
+}
+function toAnalystFinding(row, index, spanTraces, model, producedAt) {
+  const uris = row.spanIds.map((spanId) => {
+    const traces = spanTraces.get(spanId);
+    return spanEvidenceUri([...traces][0], spanId);
+  });
+  const findingId = `prime-${createHash10("sha256").update(`${index}
+${row.claim}
+${uris.join("\n")}`).digest("hex").slice(0, 12)}`;
+  return {
+    schema_version: "1.0.0",
+    finding_id: findingId,
+    analyst_id: ANALYST_ID,
+    produced_at: producedAt,
+    severity: row.severity,
+    area: row.area,
+    claim: row.claim,
+    evidence_refs: uris.map((uri) => ({ kind: "span", uri })),
+    confidence: row.confidence,
+    ...row.action ? { recommended_action: row.action } : {},
+    metadata: { engine: ANALYST_ID, model }
+  };
+}
+var httpJsonTransport = ({ url, body, signal }) => {
+  const target = new URL(url);
+  if (target.protocol !== "http:" && target.protocol !== "https:") {
+    throw new TypeError(`bridge URL must be http: or https:, got ${target.protocol}`);
+  }
+  const requestFn = target.protocol === "https:" ? httpsRequest : httpRequest;
+  const payload = JSON.stringify(body);
+  return new Promise((resolve10, reject) => {
+    const req = requestFn(
+      {
+        hostname: target.hostname,
+        port: target.port,
+        path: `${target.pathname}${target.search}`,
+        method: "POST",
+        headers: { "content-type": "application/json", "content-length": Buffer.byteLength(payload) },
+        signal
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => resolve10({ status: res.statusCode ?? 0, text: Buffer.concat(chunks).toString("utf8") }));
+        res.on("error", reject);
+      }
+    );
+    req.on("error", reject);
+    req.end(payload);
+  });
+};
+var PrimeBridgeError = class extends Error {
+};
+async function callBridge(transport, url, model, content, timeoutMs, callerSignal, turn) {
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(new Error(`${turn}bridge call exceeded ${timeoutMs}ms`)),
+    timeoutMs
+  );
+  const onCallerAbort = () => controller.abort(callerSignal.reason);
+  callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
+  if (callerSignal?.aborted) onCallerAbort();
+  let response;
+  try {
+    response = await transport({
+      url,
+      body: { model, messages: [{ role: "user", content }] },
+      signal: controller.signal
+    });
+  } catch (error) {
+    const reason = controller.signal.aborted ? controller.signal.reason : error;
+    throw new PrimeBridgeError(
+      `${turn}bridge transport failure: ${reason instanceof Error ? reason.message : String(reason)}`
+    );
+  } finally {
+    clearTimeout(timer);
+    callerSignal?.removeEventListener("abort", onCallerAbort);
+  }
+  if (response.status !== 200) {
+    throw new PrimeBridgeError(`${turn}bridge HTTP ${response.status}: ${response.text.slice(0, 500)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(response.text);
+  } catch {
+    throw new PrimeBridgeError(`${turn}bridge returned unparseable JSON (${response.text.length} bytes)`);
+  }
+  const record2 = parsed;
+  const replyContent = record2.choices?.[0]?.message?.content;
+  if (typeof replyContent !== "string" || replyContent.length === 0) {
+    throw new PrimeBridgeError(`${turn}bridge reply carries no message content`);
+  }
+  return { content: replyContent, usage: normalizeUsage(record2.usage) };
+}
+function failure(output, error) {
+  return { analyzer: ANALYST_ID, kind: "report", ok: false, output, error };
+}
+function primeAnalyzer(opts = {}) {
+  const bridgeUrl = (opts.bridgeUrl ?? process.env.TRACES_PRIME_BRIDGE_URL ?? DEFAULT_BRIDGE_URL).replace(/\/+$/, "");
+  const model = opts.model ?? process.env.TRACES_PRIME_MODEL ?? DEFAULT_MODEL;
+  const timeoutMs = opts.timeoutMs ?? positiveIntegerEnv("TRACES_PRIME_TIMEOUT_MS") ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) {
+    throw new RangeError("timeoutMs must be a positive safe integer");
+  }
+  const maxInlineChars = opts.maxInlineChars ?? DEFAULT_MAX_INLINE_CHARS;
+  const perAttributeCharCap = opts.perAttributeCharCap ?? DEFAULT_PER_ATTRIBUTE_CHAR_CAP;
+  if (!Number.isSafeInteger(maxInlineChars) || maxInlineChars < 1) {
+    throw new RangeError("maxInlineChars must be a positive safe integer");
+  }
+  if (!Number.isSafeInteger(perAttributeCharCap) || perAttributeCharCap < 1) {
+    throw new RangeError("perAttributeCharCap must be a positive safe integer");
+  }
+  const repairEnabled = opts.repair ?? true;
+  const transport = opts.transport ?? httpJsonTransport;
+  const url = `${bridgeUrl}/v1/chat/completions`;
+  return {
+    name: ANALYST_ID,
+    async analyze(otlpPath, analyzeOpts = {}) {
+      let projection;
+      try {
+        projection = await projectArtifact(otlpPath, maxInlineChars, perAttributeCharCap, analyzeOpts.signal);
+      } catch (error) {
+        return failure("", error instanceof Error ? error.message : String(error));
+      }
+      const question = analyzeOpts.prompt ?? opts.defaultPrompt ?? DEFAULT_QUESTION;
+      const deliveryLine = `delivery: ${projection.delivery.mode} (${projection.delivery.renderedChars} chars, per-attribute cap ${projection.delivery.perAttributeCharCap ?? "none"})`;
+      let reply;
+      try {
+        reply = await callBridge(
+          transport,
+          url,
+          model,
+          buildPrompt(question, projection),
+          timeoutMs,
+          analyzeOpts.signal,
+          ""
+        );
+      } catch (error) {
+        if (!(error instanceof PrimeBridgeError)) throw error;
+        return failure("", `${error.message}; ${deliveryLine}`);
+      }
+      let usage = reply.usage;
+      let parsed = extractJsonObject(reply.content);
+      let parseDefect = parseDefectOf(parsed);
+      let repairAttempted = false;
+      if (parseDefect !== null && repairEnabled) {
+        repairAttempted = true;
+        let repairReply;
+        try {
+          repairReply = await callBridge(
+            transport,
+            url,
+            model,
+            buildRepairPrompt(parseDefect, reply.content),
+            timeoutMs,
+            analyzeOpts.signal,
+            "repair-turn "
+          );
+        } catch (error) {
+          if (!(error instanceof PrimeBridgeError)) throw error;
+          return failure(reply.content, `${error.message}; ${renderUsage(usage)}`);
+        }
+        usage = mergeUsage(usage, repairReply.usage);
+        parsed = extractJsonObject(repairReply.content);
+        parseDefect = parseDefectOf(parsed);
+      }
+      if (parseDefect !== null) {
+        return failure(
+          reply.content,
+          `${parseDefect} in prime reply${repairAttempted ? " even after the bounded repair turn" : ""}; ` + renderUsage(usage)
+        );
+      }
+      const rows = parsed.findings.slice(0, MAX_FINDINGS);
+      const overflow = parsed.findings.length - rows.length;
+      const producedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const rejected = [];
+      const findings = [];
+      rows.forEach((row, index) => {
+        const decoded = findingRowDefect(row, projection.spanTraces);
+        if (typeof decoded === "string") {
+          rejected.push(`rejected[${index}]: ${decoded}`);
+          return;
+        }
+        findings.push(toAnalystFinding(decoded, index, projection.spanTraces, model, producedAt));
+      });
+      const answer = typeof parsed.answer === "string" ? parsed.answer : null;
+      const output = [
+        ...answer ? [`answer: ${answer}`] : [],
+        `findings: ${findings.length} mapped, ${rejected.length} rejected` + (overflow > 0 ? `, ${overflow} over the ${MAX_FINDINGS}-finding cap dropped` : ""),
+        ...rejected,
+        deliveryLine,
+        `repair: ${repairAttempted ? "attempted (succeeded)" : "not needed"}`,
+        renderUsage(usage),
+        ...findings.length === 0 ? ["zero findings \u2014 an honest null, not a failure"] : []
+      ].join("\n");
+      return { analyzer: ANALYST_ID, kind: "findings", ok: true, output, findings };
+    }
+  };
+}
+
+// src/redact.ts
+import { DEFAULT_REDACTION_RULES, redactValue } from "@tangle-network/agent-eval/traces";
+var CODING_REDACTION_RULES = [
+  { id: "github-token", pattern: /\b(?:gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{22,})\b/g },
+  { id: "aws-akid", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
+  { id: "slack-token", pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g },
+  { id: "jwt", pattern: /\beyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g },
+  { id: "bearer", pattern: /\bBearer\s+[A-Za-z0-9._-]{16,}/gi },
+  {
+    id: "private-key",
+    pattern: /-----BEGIN(?:[A-Z ]+)?PRIVATE KEY-----[\s\S]*?-----END(?:[A-Z ]+)?PRIVATE KEY-----/g
+  },
+  // Match the whole identifier because underscores prevent a word boundary before a secret suffix.
+  {
+    id: "assigned-secret",
+    pattern: /(?<![A-Za-z0-9_-])(?:[A-Za-z_][A-Za-z0-9_-]*)?(?:api[_-]?key|secret|token|password|passwd|access[_-]?token|client[_-]?secret)(?![A-Za-z0-9_-])\+?=(?:\$\((?:\\.|[^\\\r\n])*\)|\$\{(?:\\.|[^}\\\r\n])*\}|`(?:\\.|[^`\\\r\n])*`|\$?'(?:\\.|[^'\\\r\n])*'|\$?"(?:\\.|[^"\\\r\n])*"|\\[^\r\n]|[^\s;&|<>()"'`\\\r\n])+/gi
+  },
+  // Config-file secrets (YAML/INI line keys, JSON quoted keys) — the coverage the shell
+  // rule above deliberately gave up to spare prose ("Narrative token: x") and type
+  // annotations ("(token: string)"). The line anchor is the discriminator: config keys
+  // start their line, prose colons never do; JSON keys are safe anywhere because both
+  // sides are quoted. Identifiers must END in a secret word, same as the shell rule.
+  {
+    id: "config-secret",
+    pattern: /(?:^[ \t]*["']?(?:[A-Za-z_][A-Za-z0-9_-]*)?(?:api[_-]?key|secret|token|password|passwd|access[_-]?token|client[_-]?secret)(?![A-Za-z0-9_-])["']?[ \t]*[:=][ \t]*|["'](?:[A-Za-z_][A-Za-z0-9_-]*)?(?:api[_-]?key|secret|token|password|passwd|access[_-]?token|client[_-]?secret)["']\s*:\s*)["']?[A-Za-z0-9._\-]{12,}["']?/gim
+  },
+  // Credentials embedded in URLs — common when a prompt pastes a curl/clone line.
+  { id: "url-userinfo", pattern: /\b[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]+@/gi },
+  {
+    id: "url-secret-param",
+    pattern: /[?&](?:access[_-]?token|api[_-]?key|apikey|auth|token|secret|password|sig|signature)=[^&\s"'#)]+/gi
+  }
+];
+var TRACES_REDACTION_RULES = [...DEFAULT_REDACTION_RULES, ...CODING_REDACTION_RULES];
+function redactSpans(spans, rules = TRACES_REDACTION_RULES) {
+  const report = { redactionCount: 0, byRule: {} };
+  const out = spans.map((s) => {
+    const attributes2 = redactValue(s.attributes, rules, report).value;
+    normalizeToolIoAttributes(attributes2);
+    let status = s.status;
+    if (status.message) {
+      const m = redactValue(status.message, rules, report).value;
+      if (typeof m === "string" && m !== status.message) status = { ...status, message: m };
+    }
+    return { ...s, attributes: attributes2, status };
+  });
+  return { spans: out, report };
+}
+async function applyRedactor(spans, redactor) {
+  const capturedKeys = ["content", ...TOOL_IO_VALUE_KEYS];
+  const fields = [];
+  const texts = [];
+  spans.forEach((s, i) => {
+    for (const key of capturedKeys) {
+      const value = s.attributes[key];
+      if (typeof value === "string" && value.length > 0) {
+        fields.push({ spanIndex: i, key });
+        texts.push(value);
+      }
+    }
+    if (s.status.message) {
+      fields.push({ spanIndex: i, key: "status.message" });
+      texts.push(s.status.message);
+    }
+  });
   const out = spans.map((s) => ({ ...s, attributes: { ...s.attributes } }));
   if (texts.length === 0) {
     for (const span2 of out) normalizeToolIoAttributes(span2.attributes);
@@ -10703,7 +11178,7 @@ async function applyRedactor(spans, redactor) {
 }
 
 // src/file-export.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { mkdtemp as mkdtemp4, readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
 import { join as join24 } from "path";
@@ -10741,7 +11216,7 @@ function stableJson(value) {
   });
 }
 function hashId(value, chars = 16) {
-  return createHash10("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
+  return createHash11("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
 }
 function isoTime2(value) {
   if (typeof value === "string") {
@@ -10902,12 +11377,12 @@ function policyEvidenceToSpans(records) {
       "traces.provenance.evidence_kind": record2.provenance.evidenceKind,
       "traces.provenance.otlp_path": record2.provenance.otlpPath,
       "traces.provenance.source_sha256": record2.provenance.sourceSha256,
-      [ATTR2.SUBJECT_KEY]: record2.repo.subjectKey,
-      [ATTR2.GIT_REPOSITORY]: record2.repo.repository,
-      [ATTR2.GIT_BRANCH_NAME]: record2.repo.branch,
-      [ATTR2.GIT_COMMIT]: record2.repo.commit,
-      [ATTR2.CWD]: record2.repo.cwd ?? record2.session.cwd,
-      [ATTR2.REPO_RESOLUTION_SOURCE]: record2.repo.resolutionSource
+      [ATTR.SUBJECT_KEY]: record2.repo.subjectKey,
+      [ATTR.GIT_REPOSITORY]: record2.repo.repository,
+      [ATTR.GIT_BRANCH_NAME]: record2.repo.branch,
+      [ATTR.GIT_COMMIT]: record2.repo.commit,
+      [ATTR.CWD]: record2.repo.cwd ?? record2.session.cwd,
+      [ATTR.REPO_RESOLUTION_SOURCE]: record2.repo.resolutionSource
     };
     return span({
       traceId,
@@ -11004,6 +11479,54 @@ function eventKind(row, type) {
   if (lowered.includes("llm") || lowered === "token") return { kind: "LLM" };
   return { kind: "CHAIN" };
 }
+function sandboxEventsEnvironment(context, rows) {
+  const ready = rows.find((row) => eventType(row) === "runtime.ready");
+  const readyData = ready && isObject5(ready.data) ? ready.data : void 0;
+  const pick = (keys) => findStringKey(context, keys, 2) ?? (readyData ? findStringKey(readyData, keys, 2) : void 0);
+  const image = pick(["image"]);
+  const imageDigest = pick(["imageDigest", "image_digest"]);
+  const sandboxId = pick(["sandboxId", "sandbox_id"]);
+  const cwd = pick(["cwd", "workspaceRoot", "workspace_root"]);
+  if (!image && !imageDigest && !sandboxId && !cwd) return null;
+  return {
+    ...image ? { image } : {},
+    ...imageDigest ? { imageDigest } : {},
+    ...sandboxId ? { sandboxId } : {},
+    cwd: cwd ?? null
+  };
+}
+function llmEventUsage(row) {
+  const num = (keys) => {
+    for (const key of keys) {
+      const direct = numberValue(row[key]);
+      if (direct !== void 0) return direct;
+      for (const nest of ["data", "usage", "tokenUsage"]) {
+        const container = row[nest];
+        if (!isObject5(container)) continue;
+        const value = numberValue(container[key]);
+        if (value !== void 0) return value;
+        for (const inner of ["usage", "tokenUsage"]) {
+          const deep = container[inner];
+          if (isObject5(deep)) {
+            const deepValue = numberValue(deep[key]);
+            if (deepValue !== void 0) return deepValue;
+          }
+        }
+      }
+    }
+    return void 0;
+  };
+  const model = findStringKey(row, ["model"], 3);
+  const inputTokens = num(["prompt_tokens", "input_tokens", "inputTokens"]);
+  const outputTokens = num(["completion_tokens", "output_tokens", "outputTokens"]);
+  const costUsd = num(["totalCostUsd", "total_cost_usd", "costUsd", "cost_usd"]);
+  return {
+    ...model ? { model } : {},
+    ...inputTokens !== void 0 ? { inputTokens } : {},
+    ...outputTokens !== void 0 ? { outputTokens } : {},
+    ...costUsd !== void 0 ? { costUsd } : {}
+  };
+}
 function sandboxEventsToSpans(rows, wrapper) {
   const context = wrapper ?? {};
   const sessionId = findStringKey(context, ["session_id", "sessionId"], 3) ?? findStringKey(rows, ["session_id", "sessionId"], 4);
@@ -11074,13 +11597,15 @@ function sandboxEventsToSpans(rows, wrapper) {
       tool: kind === "TOOL" ? tool ?? type : null,
       step: index,
       content: capText(stableJson(row)),
-      extra
+      extra,
+      ...kind === "LLM" ? llmEventUsage(row) : {}
     }));
   });
+  stampEnvironmentAttrs(spans, sandboxEventsEnvironment(context, rows) ?? void 0);
   if (!sessionId) return spans;
   return spans.map((item) => ({
     ...item,
-    attributes: { ...item.attributes, [ATTR2.SESSION_ID]: sessionId }
+    attributes: { ...item.attributes, [ATTR.SESSION_ID]: sessionId }
   }));
 }
 function statusCode2(value) {
@@ -11159,7 +11684,7 @@ function intelligenceSpansToSpans(rows) {
     };
     copyDefined(extra, {
       "traces.row.id": stringValue3(row.id),
-      [ATTR2.SESSION_ID]: sessionId,
+      [ATTR.SESSION_ID]: sessionId,
       "session.id": sessionId,
       "run.id": stringValue3(row.run_id),
       "thread.id": stringValue3(row.thread_id),
@@ -12534,6 +13059,47 @@ var SEVERITY_BADGE2 = {
   low: "\u{1F535} LOW",
   info: "\u2139\uFE0F  INFO"
 };
+function sessionReportSource(ref, spans, sessionIdOverride) {
+  const root = spans.find((item) => item.parent_span_id === null) ?? spans[0];
+  const prompt = spans.find(
+    (item) => item.name === "user.prompt" && item.attributes[ACTOR_ATTR] === "human"
+  ) ?? spans.find((item) => item.name === "user.prompt") ?? spans.find(
+    (item) => item.attributes["span.type"] === "interaction" && typeof item.attributes.content === "string"
+  );
+  const content = typeof prompt?.attributes.content === "string" ? prompt.attributes.content : "";
+  const firstLine = content.split(/\r?\n/, 1)[0].trim();
+  const subject = firstLine.length > 240 ? `${firstLine.slice(0, 240)}\u2026 [+${firstLine.length - 240} chars]` : firstLine;
+  const role = root?.attributes["traces.session.role"];
+  const parentSessionId = root?.attributes["traces.parent_session_id"];
+  const relationship = describeSessionRelationship(ref, spans);
+  const corruptionDigest2 = root?.attributes[ATTR.CORRUPTION_DIGEST];
+  const sessionId = [
+    sessionIdOverride,
+    root ? sessionIdFromAttributes(root.attributes) : void 0,
+    root?.trace_id,
+    ref.sessionId
+  ].find((value) => typeof value === "string" && value.length > 0);
+  return {
+    sessionId,
+    path: ref.path,
+    subject,
+    role: role === "operator" || role === "child" ? role : "unknown",
+    ...typeof parentSessionId === "string" ? { parentSessionId } : {},
+    childSessionIds: relationship.childSessionIds,
+    ...relationship.depth !== void 0 ? { depth: relationship.depth } : {},
+    ...relationship.agentNickname ? { agentNickname: relationship.agentNickname } : {},
+    ...relationship.agentRole ? { agentRole: relationship.agentRole } : {},
+    ...relationship.agentPath ? { agentPath: relationship.agentPath } : {},
+    ...relationship.taskScope ? { taskScope: relationship.taskScope } : {},
+    ...relationship.turnId ? { turnId: relationship.turnId } : {},
+    integrity: ref.integrity?.status ?? "complete",
+    ...ref.integrity ? {
+      corruptionCount: ref.integrity.corruptions.length,
+      ...typeof corruptionDigest2 === "string" ? { corruptionDigest: corruptionDigest2 } : {},
+      corruptions: ref.integrity.corruptions.slice(0, CORRUPTION_RECEIPT_DISPLAY_LIMIT)
+    } : {}
+  };
+}
 function deterministicSummaryText(summary) {
   const parts = [];
   if (summary.stuckLoops > 0) parts.push(`${summary.stuckLoops} stuck loop(s)`);
@@ -13684,27 +14250,27 @@ async function saveReport(path, report) {
 }
 
 // src/live.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 var VERIFY_RE = /\b(test|tests|vitest|jest|pytest|go test|cargo test|tsc|typecheck|lint|biome|eslint|build|check:invariants|preflight)\b/i;
 var CHANGE_RE = /\b(apply_patch|edit|write|create|delete|rename|replace|update|git apply|sed -i|perl -pi|tee\s|cat\s+>)/i;
 var CLAIM_DONE_RE = /\b(done|fixed|complete|completed|implemented|merged|verified|all green|tests pass|ready|works now)\b/i;
-var sleep = (ms2, signal) => new Promise((resolve8) => {
+var sleep = (ms2, signal) => new Promise((resolve10) => {
   if (signal?.aborted) {
-    resolve8();
+    resolve10();
     return;
   }
   const onAbort = () => {
     clearTimeout(t);
-    resolve8();
+    resolve10();
   };
   const t = setTimeout(() => {
     signal?.removeEventListener("abort", onAbort);
-    resolve8();
+    resolve10();
   }, ms2);
   signal?.addEventListener("abort", onAbort, { once: true });
 });
 function hash(parts) {
-  return createHash11("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
+  return createHash12("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
 }
 function asString(value) {
   if (typeof value === "string" && value.trim()) return value;
@@ -15174,13 +15740,13 @@ function aborted(signal) {
   return signal !== void 0 && signal.aborted;
 }
 function sleep2(msDelay, signal) {
-  return new Promise((resolve8) => {
-    const timer = setTimeout(resolve8, msDelay);
+  return new Promise((resolve10) => {
+    const timer = setTimeout(resolve10, msDelay);
     signal?.addEventListener(
       "abort",
       () => {
         clearTimeout(timer);
-        resolve8();
+        resolve10();
       },
       { once: true }
     );
@@ -15520,11 +16086,11 @@ async function collectSessionWorkflow(adapter, seeds, options = {}) {
 }
 
 // src/session-selection.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { createReadStream as createReadStream2 } from "fs";
 async function fileSha256(path, signal) {
   signal?.throwIfAborted();
-  const hash2 = createHash12("sha256");
+  const hash2 = createHash13("sha256");
   try {
     for await (const chunk of createReadStream2(path, { signal })) {
       signal?.throwIfAborted();
@@ -15552,7 +16118,7 @@ async function sourceSnapshot(adapter, ref, signal) {
     signal?.throwIfAborted();
     files.push({ path, sha256: await fileSha256(path, signal) });
   }
-  const sha2562 = files.length === 1 ? files[0].sha256 : createHash12("sha256").update(JSON.stringify(files)).digest("hex");
+  const sha2562 = files.length === 1 ? files[0].sha256 : createHash13("sha256").update(JSON.stringify(files)).digest("hex");
   return { sha256: sha2562, files };
 }
 function summarizeWorkflows(workflows) {
@@ -15813,14 +16379,30 @@ async function collectContextRoot(root) {
     const summary = await summarizeFile(join31(evolve, name), "evolve-jsonl");
     if (summary) files.push(summary);
   }
-  for (const name of ["scorecard.json"]) {
+  for (const name of ["scorecard.json", "current.json"]) {
     const summary = await summarizeFile(join31(evolve, name), "evolve-json");
     if (summary) files.push(summary);
   }
   files.push(...await walkMarkdown(join31(evolve, "reflections"), "reflection"));
   files.push(...await walkMarkdown(join31(evolve, "handoffs"), "handoff"));
+  for (const name of await listEvolveRootFiles(evolve)) {
+    if (/^handoff-.*\.md$/.test(name)) {
+      const summary = await summarizeFile(join31(evolve, name), "handoff");
+      if (summary) files.push(summary);
+    }
+  }
+  const progress = await summarizeFile(join31(evolve, "progress.md"), "other");
+  if (progress) files.push(progress);
   return { root, files: files.sort((a, b) => a.path.localeCompare(b.path)) };
 }
+async function listEvolveRootFiles(evolve) {
+  try {
+    const entries = await readdir18(evolve, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
 async function collectContextIndex(records) {
   const rootSet = /* @__PURE__ */ new Set();
   for (const record2 of records) {
@@ -15869,14 +16451,641 @@ async function writeSessionIndexFile(index, outPath) {
   return path;
 }
 
+// src/bundle.ts
+import { createHash as createHash14 } from "crypto";
+import { readFileSync as readFileSync5 } from "fs";
+import { cp, mkdir as mkdir5, readdir as readdir19, readFile as readFile14, stat as stat17, writeFile as writeFile9 } from "fs/promises";
+import { join as join32, relative as relative5, resolve as resolve8, sep as sep2 } from "path";
+var SESSION_WINDOW_PAD_MS = 15 * 60 * 1e3;
+var KNOWN_LIMITS = [
+  "'what was decided' is prose-only: handoff, progress, and reflection files are copied as markdown with no structured decision extraction",
+  "'what was measured' is split between experiments.jsonl free-text fields and progress/handoff markdown tables",
+  "session-to-ledger join is by timestamp/cwd inference: ledger rows are window-sliced, not linked by transcript path",
+  "progress.md is copied whole; no session-dated section extraction is performed",
+  "open pull-request state is not captured: the bundler makes no network calls"
+];
+function sha256Hex(bytes) {
+  return createHash14("sha256").update(bytes).digest("hex");
+}
+function bundlePath(...parts) {
+  return parts.join("/");
+}
+async function statOrNull(path) {
+  try {
+    return await stat17(path);
+  } catch (error) {
+    if (isMissingPathError(error)) return null;
+    if (error.code === "ENOTDIR") return null;
+    throw error;
+  }
+}
+function sliceJsonlByWindow(text2, windowStartMs, windowEndMs) {
+  const kept = [];
+  let totalRows = 0;
+  let unparseableTsRows = 0;
+  for (const line of text2.split("\n")) {
+    if (!line.trim()) continue;
+    totalRows += 1;
+    let tsMs = Number.NaN;
+    try {
+      const row = JSON.parse(line);
+      const ts = row !== null && typeof row === "object" && !Array.isArray(row) ? row.ts : void 0;
+      if (typeof ts === "string") tsMs = Date.parse(ts);
+    } catch {
+    }
+    if (Number.isNaN(tsMs)) {
+      unparseableTsRows += 1;
+      continue;
+    }
+    if (tsMs >= windowStartMs && tsMs <= windowEndMs) kept.push(line);
+  }
+  return { kept, totalRows, unparseableTsRows };
+}
+async function runGitLog(cwd, sinceIso, untilIso) {
+  const { execFile: execFile2 } = await import("child_process");
+  const { promisify: promisify2 } = await import("util");
+  const run = promisify2(execFile2);
+  try {
+    const { stdout } = await run(
+      "git",
+      ["-C", cwd, "log", `--since=${sinceIso}`, `--until=${untilIso}`, "--date=iso-strict", "--pretty=format:%H %ad %an %s"],
+      { timeout: 5e3 }
+    );
+    return { succeeded: true, stdout };
+  } catch (error) {
+    return { succeeded: false, error: error instanceof Error ? error.message.split("\n", 1)[0] : String(error) };
+  }
+}
+async function listSessionBundleFiles(root) {
+  const out = [];
+  const pending = [resolve8(root)];
+  while (pending.length > 0) {
+    const dir = pending.pop();
+    for (const entry of await readdir19(dir, { withFileTypes: true })) {
+      const path = join32(dir, entry.name);
+      if (entry.isDirectory()) pending.push(path);
+      else if (entry.isFile()) out.push(relative5(resolve8(root), path).split(sep2).join("/"));
+    }
+  }
+  return out.sort();
+}
+async function sliceLedgerJsonl(ctx, name) {
+  const source = join32(ctx.evolveDir, name);
+  const s = await statOrNull(source);
+  if (!s?.isFile()) {
+    ctx.absent.push({ path: bundlePath("ledger", name), reason: `no ${name} at ${source}` });
+    return;
+  }
+  const text2 = await readFile14(source, "utf8");
+  const target = join32(ctx.ledgerDir, name);
+  if (ctx.windowStartMs === null || ctx.windowEndMs === null) {
+    await writeFile9(target, text2, "utf8");
+    ctx.slices.push({ path: bundlePath("ledger", name), source, rule: "copied-whole" });
+    return;
+  }
+  const slice = sliceJsonlByWindow(text2, ctx.windowStartMs, ctx.windowEndMs);
+  await writeFile9(target, slice.kept.length > 0 ? `${slice.kept.join("\n")}
+` : "", "utf8");
+  ctx.slices.push({
+    path: bundlePath("ledger", name),
+    source,
+    rule: "session-window-rows",
+    totalRows: slice.totalRows,
+    keptRows: slice.kept.length,
+    unparseableTsRows: slice.unparseableTsRows
+  });
+}
+async function copyLedgerWhole(ctx, name) {
+  const source = join32(ctx.evolveDir, name);
+  const s = await statOrNull(source);
+  if (!s?.isFile()) {
+    ctx.absent.push({ path: bundlePath("ledger", name), reason: `no ${name} at ${source}` });
+    return;
+  }
+  await cp(source, join32(ctx.ledgerDir, name));
+  ctx.slices.push({ path: bundlePath("ledger", name), source, rule: "copied-whole" });
+}
+async function copyLatestHandoff(ctx) {
+  let names;
+  try {
+    names = (await readdir19(ctx.evolveDir, { withFileTypes: true })).filter((entry) => entry.isFile() && /^handoff-.*\.md$/.test(entry.name)).map((entry) => entry.name).sort();
+  } catch {
+    names = [];
+  }
+  const latest = names[names.length - 1];
+  if (!latest) {
+    ctx.absent.push({
+      path: bundlePath("ledger", "handoff-*.md"),
+      reason: `no flat handoff-*.md files in ${ctx.evolveDir}`
+    });
+    return;
+  }
+  const source = join32(ctx.evolveDir, latest);
+  await cp(source, join32(ctx.ledgerDir, latest));
+  ctx.slices.push({ path: bundlePath("ledger", latest), source, rule: "latest-by-name" });
+}
+async function copyWindowReflections(ctx) {
+  const reflectionsDir = join32(ctx.evolveDir, "reflections");
+  const s = await statOrNull(reflectionsDir);
+  if (!s?.isDirectory()) {
+    ctx.absent.push({
+      path: bundlePath("ledger", "reflections"),
+      reason: `no reflections directory at ${reflectionsDir}`
+    });
+    return;
+  }
+  const names = (await readdir19(reflectionsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort();
+  const windowed = ctx.windowStartMs === null || ctx.windowEndMs === null ? names : names.filter((name) => {
+    const date = name.match(/(\d{4}-\d{2}-\d{2})/)?.[1];
+    if (!date) return false;
+    const startDate = new Date(ctx.windowStartMs).toISOString().slice(0, 10);
+    const endDate = new Date(ctx.windowEndMs).toISOString().slice(0, 10);
+    return date >= startDate && date <= endDate;
+  });
+  if (windowed.length === 0) {
+    ctx.absent.push({
+      path: bundlePath("ledger", "reflections"),
+      reason: `no reflections dated inside the session window in ${reflectionsDir}`
+    });
+    return;
+  }
+  await mkdir5(join32(ctx.ledgerDir, "reflections"), { recursive: true });
+  const rule = ctx.windowStartMs === null ? "copied-whole" : "session-window-dated-files";
+  for (const name of windowed) {
+    const source = join32(reflectionsDir, name);
+    await cp(source, join32(ctx.ledgerDir, "reflections", name));
+    ctx.slices.push({ path: bundlePath("ledger", "reflections", name), source, rule });
+  }
+}
+async function assembleSessionBundle(opts) {
+  const { adapter, ref } = opts;
+  const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  let transcriptBytes;
+  try {
+    transcriptBytes = await readFile14(ref.path);
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      throw new Error(
+        `session transcript not found at ${ref.path} \u2014 a bundle cannot be assembled without its transcript`
+      );
+    }
+    throw error;
+  }
+  const transcriptSha256 = sha256Hex(transcriptBytes);
+  const spans = await parseSession(adapter, ref, { signal: opts.signal });
+  const outDir = resolve8(opts.outDir);
+  await mkdir5(outDir, { recursive: true });
+  if ((await readdir19(outDir)).length > 0) {
+    throw new Error(
+      `bundle output directory ${outDir} is not empty \u2014 pass a new directory so one bundle holds exactly one session`
+    );
+  }
+  const absent = [];
+  const slices = [];
+  await mkdir5(join32(outDir, "session"), { recursive: true });
+  await writeFile9(join32(outDir, "session", "transcript.jsonl"), transcriptBytes);
+  const subagentsSource = join32(ref.path.replace(/\.jsonl$/, ""), "subagents");
+  if ((await statOrNull(subagentsSource))?.isDirectory()) {
+    await cp(subagentsSource, join32(outDir, "session", "subagents"), { recursive: true });
+  } else {
+    absent.push({ path: bundlePath("session", "subagents"), reason: `no subagents directory at ${subagentsSource}` });
+  }
+  await mkdir5(join32(outDir, "derived"), { recursive: true });
+  const otlpPath = join32(outDir, "derived", "trace.otlp.jsonl");
+  const investigation = await runTraceInvestigation({
+    spans,
+    harness: ref.harness,
+    sources: [sessionReportSource(ref, spans)],
+    cwds: ref.cwd ? [ref.cwd] : [],
+    minLoopOccurrences: opts.minLoopOccurrences,
+    otlpOutPath: otlpPath,
+    generatedAt,
+    signal: opts.signal,
+    log: opts.log
+  });
+  await writeFile9(join32(outDir, "derived", "report.md"), investigation.report, "utf8");
+  const evidence3 = await buildPolicyEvidenceRecord(ref, spans, {
+    generatedAt,
+    minLoopOccurrences: opts.minLoopOccurrences,
+    // Bundle-relative pointer: the bundle must stay internally valid when moved.
+    otlpPath: bundlePath("derived", "trace.otlp.jsonl"),
+    sourceSha256: transcriptSha256
+  });
+  await writeFile9(join32(outDir, "derived", "evidence.jsonl"), serializePolicyEvidence([evidence3]), "utf8");
+  const index = await buildSessionIndexFromRows([{ ref, spans }], {
+    generatedAt,
+    minLoopOccurrences: opts.minLoopOccurrences,
+    selection: { command: "bundle", harness: ref.harness, session: ref.sessionId }
+  });
+  await writeFile9(join32(outDir, "derived", "session-index.json"), serializeSessionIndex(index), "utf8");
+  const { firstSpanAt, lastSpanAt } = evidence3.metrics;
+  const windowStartMs = firstSpanAt !== null ? Date.parse(firstSpanAt) - SESSION_WINDOW_PAD_MS : null;
+  const windowEndMs = lastSpanAt !== null ? Date.parse(lastSpanAt) + SESSION_WINDOW_PAD_MS : null;
+  const contextRoot = await findContextRoot(ref.cwd);
+  if (!contextRoot) {
+    absent.push({ path: "ledger", reason: `no context root found from session cwd ${ref.cwd ?? "(unknown)"}` });
+  } else {
+    const evolveDir = join32(contextRoot, ".evolve");
+    if (!(await statOrNull(evolveDir))?.isDirectory()) {
+      absent.push({ path: "ledger", reason: `no .evolve ledger at ${evolveDir}` });
+    } else {
+      const ledgerDir = join32(outDir, "ledger");
+      await mkdir5(ledgerDir, { recursive: true });
+      const ctx = { evolveDir, ledgerDir, windowStartMs, windowEndMs, slices, absent };
+      await sliceLedgerJsonl(ctx, "experiments.jsonl");
+      await sliceLedgerJsonl(ctx, "skill-runs.jsonl");
+      await copyLedgerWhole(ctx, "current.json");
+      await copyLedgerWhole(ctx, "scorecard.json");
+      await copyLedgerWhole(ctx, "progress.md");
+      await copyLatestHandoff(ctx);
+      await copyWindowReflections(ctx);
+    }
+  }
+  const gitLogPath = bundlePath("repo", "git-log.txt");
+  if (!ref.cwd) {
+    absent.push({ path: gitLogPath, reason: "session has no recorded cwd to read git history from" });
+  } else if (windowStartMs === null || windowEndMs === null) {
+    absent.push({ path: gitLogPath, reason: "session window unavailable (spans carry no timestamps)" });
+  } else {
+    const log = await runGitLog(ref.cwd, new Date(windowStartMs).toISOString(), new Date(windowEndMs).toISOString());
+    if (log.succeeded) {
+      await mkdir5(join32(outDir, "repo"), { recursive: true });
+      await writeFile9(join32(outDir, "repo", "git-log.txt"), log.stdout ? `${log.stdout}
+` : "", "utf8");
+    } else {
+      absent.push({ path: gitLogPath, reason: `git log failed in ${ref.cwd}: ${log.error}` });
+    }
+  }
+  const files = await hashSessionBundleFiles(outDir);
+  const manifest = {
+    schemaVersion: 2,
+    kind: "traces.session_bundle",
+    view: "full",
+    createdAt: generatedAt,
+    provenance: {
+      sessionId: ref.sessionId,
+      harness: ref.harness,
+      cwd: ref.cwd,
+      transcriptPath: resolve8(ref.path),
+      transcriptSha256,
+      contextRoot,
+      tracesVersion: tracesPackageVersion(),
+      sessionWindow: { firstSpanAt, lastSpanAt, padMs: SESSION_WINDOW_PAD_MS }
+    },
+    files,
+    absent,
+    // The full view is the whole record: it drops nothing, and says so rather
+    // than leaving a reader to infer completeness from a missing field.
+    excluded: [],
+    ledgerSlices: slices,
+    knownLimits: KNOWN_LIMITS
+  };
+  const manifestPath = await writeSessionBundleManifest(outDir, manifest);
+  return { directory: outDir, manifestPath, manifest };
+}
+async function hashSessionBundleFiles(root) {
+  const files = [];
+  for (const path of await listSessionBundleFiles(root)) {
+    const bytes = await readFile14(join32(root, path));
+    files.push({ path, bytes: bytes.length, sha256: sha256Hex(bytes) });
+  }
+  return files;
+}
+async function writeSessionBundleManifest(outDir, manifest) {
+  const manifestPath = join32(outDir, "manifest.json");
+  await writeFile9(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  return manifestPath;
+}
+async function readSessionBundleManifest(bundleDir) {
+  const path = join32(resolve8(bundleDir), "manifest.json");
+  let text2;
+  try {
+    text2 = await readFile14(path, "utf8");
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      throw new Error(`no manifest.json at ${path} \u2014 ${bundleDir} is not a traces session bundle`);
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text2);
+  } catch (error) {
+    throw new Error(`${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const manifest = parsed;
+  if (manifest?.kind !== "traces.session_bundle") {
+    throw new Error(`${path} has kind ${JSON.stringify(manifest?.kind)}, expected "traces.session_bundle"`);
+  }
+  if (manifest.schemaVersion !== 2) {
+    throw new Error(
+      `${path} is bundle schemaVersion ${JSON.stringify(manifest.schemaVersion)}; this traces reads 2. Re-run \`traces bundle\` to assemble it with the view-aware manifest.`
+    );
+  }
+  if (manifest.view !== "full" && manifest.view !== "evidence-only") {
+    throw new Error(`${path} has view ${JSON.stringify(manifest.view)}, expected "full" or "evidence-only"`);
+  }
+  return manifest;
+}
+var cachedVersion;
+function tracesPackageVersion() {
+  if (cachedVersion) return cachedVersion;
+  const pkg = JSON.parse(
+    readFileSync5(new URL("../package.json", import.meta.url), "utf8")
+  );
+  if (typeof pkg.version !== "string" || !pkg.version) throw new Error("package.json is missing version");
+  cachedVersion = pkg.version;
+  return cachedVersion;
+}
+
+// src/bundle-view.ts
+import { createHash as createHash15 } from "crypto";
+import { mkdir as mkdir6, readdir as readdir20, readFile as readFile15, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname9, join as join33, resolve as resolve9 } from "path";
+var EVIDENCE_ONLY_ALLOW_LIST = [
+  {
+    path: "derived/session-index.json",
+    owned: true,
+    carries: "per-session counts, tool names, models, and nearby-context file metadata"
+  },
+  {
+    path: "derived/evidence.jsonl",
+    owned: true,
+    carries: "execution statistics, token and tool totals, loop and error counts"
+  },
+  {
+    path: "ledger/current.json",
+    owned: false,
+    carries: "the repo ledger current-state record"
+  },
+  {
+    path: "ledger/scorecard.json",
+    owned: false,
+    carries: "the repo ledger scorecard rows"
+  },
+  {
+    path: "ledger/skill-runs.jsonl",
+    owned: false,
+    carries: "skill-run rows: skill name, timestamp, and outcome fields"
+  }
+];
+var EXCLUSION_RULES = [
+  {
+    matches: (path) => path === "session/transcript.jsonl" || path.startsWith("session/"),
+    rule: "session-source",
+    reason: "raw session text: the transcript and any subagent transcript hold every word the session wrote, including the shell call that authored an earlier report"
+  },
+  {
+    matches: (path) => path === "derived/report.md",
+    rule: "session-text-derived",
+    reason: "the deterministic report quotes the session verbatim: the first prompt line and evidence excerpts per finding"
+  },
+  {
+    matches: (path) => path === "derived/trace.otlp.jsonl",
+    rule: "session-text-derived",
+    reason: "spans carry input.value, output.value and content: the full prompt and response text of every turn"
+  },
+  {
+    matches: (path) => path === "ledger/progress.md",
+    rule: "authored-prose",
+    reason: "progress notes are written at session close and restate what the session concluded"
+  },
+  {
+    matches: (path) => /^ledger\/handoff-.*\.md$/.test(path),
+    rule: "authored-prose",
+    reason: "a handoff is the session conclusion in prose"
+  },
+  {
+    matches: (path) => path.startsWith("ledger/reflections/"),
+    rule: "authored-prose",
+    reason: "a reflection is the session conclusion in prose"
+  },
+  {
+    matches: (path) => path === "ledger/experiments.jsonl",
+    rule: "authored-prose",
+    reason: "experiment rows carry free-text verdict and note fields that restate what the session concluded"
+  },
+  {
+    matches: (path) => path === "repo/git-log.txt",
+    rule: "authored-prose",
+    reason: "commit subjects are prose the session authored"
+  },
+  {
+    matches: () => true,
+    rule: "not-allow-listed",
+    reason: "the evidence-only view carries an explicit allow-list of counted artifacts, and this path is not on it"
+  }
+];
+var SIGNATURE_WORDS = 8;
+var MIN_WORD_TOKENS = 7;
+function scrubIdentifiers(line) {
+  return line.replace(/[a-z][a-z0-9+.-]*:\/\/\S*/gi, " ").replace(/\/?(?:[\w.@+~-]+\/)+[\w.@+~-]*/g, " ").replace(/\b[0-9a-f-]{8,}\b/gi, " ");
+}
+var PACKAGE_CONSTANT_PROSE = [POLICY_EVIDENCE_NOTE];
+function stripPackageConstants(text2) {
+  let out = text2;
+  for (const constant of PACKAGE_CONSTANT_PROSE) out = out.split(constant).join(" ");
+  return out;
+}
+function collectJsonStrings(value, into) {
+  if (typeof value === "string") into.push(value);
+  else if (Array.isArray(value)) for (const item of value) collectJsonStrings(item, into);
+  else if (value !== null && typeof value === "object") {
+    for (const item of Object.values(value)) collectJsonStrings(item, into);
+  }
+}
+function proseFragments(line) {
+  const trimmed = line.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      const strings = [];
+      collectJsonStrings(parsed, strings);
+      return strings;
+    } catch {
+    }
+  }
+  return [line];
+}
+function sessionTextSignatures(text2) {
+  const out = /* @__PURE__ */ new Set();
+  for (const line of stripPackageConstants(text2).split("\n")) {
+    for (const fragment of proseFragments(line)) {
+      const words = scrubIdentifiers(fragment).toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(" ").filter(Boolean);
+      for (let i = 0; i + SIGNATURE_WORDS <= words.length; i++) {
+        const window = words.slice(i, i + SIGNATURE_WORDS);
+        if (window.filter((word) => /^[a-z]+$/.test(word)).length < MIN_WORD_TOKENS) continue;
+        out.add(window.join(" "));
+      }
+    }
+  }
+  return out;
+}
+async function findSessionTextLeaks(opts) {
+  const index = /* @__PURE__ */ new Map();
+  const carried = [];
+  for (const path of opts.carriedPaths) {
+    const signatures = sessionTextSignatures(await readFile15(join33(opts.viewDir, path), "utf8"));
+    carried.push({ path, signatures: signatures.size });
+    for (const signature of signatures) if (!index.has(signature)) index.set(signature, path);
+  }
+  const hits = /* @__PURE__ */ new Map();
+  const comparedSources = [];
+  let sourceSignatures = 0;
+  for (const sourcePath of opts.excludedPaths) {
+    const signatures = sessionTextSignatures(await readFile15(join33(opts.sourceDir, sourcePath), "utf8"));
+    comparedSources.push(sourcePath);
+    sourceSignatures += signatures.size;
+    for (const signature of signatures) {
+      const viewPath = index.get(signature);
+      if (viewPath === void 0) continue;
+      const hit = hits.get(viewPath) ?? { matched: /* @__PURE__ */ new Set(), sources: /* @__PURE__ */ new Set(), example: signature };
+      hit.matched.add(signature);
+      hit.sources.add(sourcePath);
+      hits.set(viewPath, hit);
+    }
+  }
+  const leaks = [...hits].map(([viewPath, hit]) => ({
+    viewPath,
+    sources: [...hit.sources].sort(),
+    signatures: hit.matched.size,
+    example: hit.example
+  }));
+  return { leaks, carried, comparedSources, sourceSignatures };
+}
+function classifyEvidenceOnlyPath(path) {
+  const allowed = EVIDENCE_ONLY_ALLOW_LIST.find((entry) => entry.path === path);
+  if (allowed) return { carried: true, owned: allowed.owned, carries: allowed.carries };
+  const rule = EXCLUSION_RULES.find((entry) => entry.matches(path));
+  return { carried: false, rule: rule.rule, reason: rule.reason };
+}
+var EVIDENCE_ONLY_LIMITS = [
+  "the exclusion is verbatim-tight, not paraphrase-tight: a conclusion restated in different words inside a carried artifact is not detectable by content signatures",
+  "ledger prose (progress, handoffs, reflections) and experiment free-text fields are excluded whole; a measured experiment result is readable only from the full bundle, under audit rules",
+  "the view carries counts, names, identifiers, timestamps and hashes; a question that needs the words of a turn cannot be answered from it"
+];
+async function projectSessionBundle(opts) {
+  if (opts.view !== "evidence-only") {
+    throw new Error(
+      `unsupported bundle view ${JSON.stringify(opts.view)}. The full view IS the bundle \`traces bundle\` assembles, so there is nothing to project into it; the projectable view is "evidence-only".`
+    );
+  }
+  const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const sourceDir = resolve9(opts.bundleDir);
+  const source = await readSessionBundleManifest(sourceDir);
+  if (source.view !== "full") {
+    throw new Error(
+      `${sourceDir} is already the ${source.view} view \u2014 project from the full bundle, not from a view of it`
+    );
+  }
+  const outDir = resolve9(opts.outDir);
+  await mkdir6(outDir, { recursive: true });
+  if ((await readdir20(outDir)).length > 0) {
+    throw new Error(
+      `view output directory ${outDir} is not empty \u2014 pass a new directory so one directory holds exactly one view`
+    );
+  }
+  const sourceHashes = new Map(source.files.map((file) => [file.path, file]));
+  const carriedPaths = [];
+  const carries = /* @__PURE__ */ new Map();
+  const excluded = [];
+  const candidates = [];
+  for (const path of await listSessionBundleFiles(sourceDir)) {
+    if (path === "manifest.json") continue;
+    const bytes = await readFile15(join33(sourceDir, path));
+    const sha2562 = createHash15("sha256").update(bytes).digest("hex");
+    const recorded = sourceHashes.get(path);
+    if (!recorded) {
+      throw new Error(
+        `${join33(sourceDir, path)} is not listed in the bundle manifest \u2014 the bundle changed after assembly and cannot be projected; re-run \`traces bundle\``
+      );
+    }
+    if (recorded.sha256 !== sha2562) {
+      throw new Error(
+        `${join33(sourceDir, path)} does not match its manifest hash (${recorded.sha256} recorded, ${sha2562} on disk) \u2014 the bundle changed after assembly and cannot be projected; re-run \`traces bundle\``
+      );
+    }
+    const verdict = classifyEvidenceOnlyPath(path);
+    if (!verdict.carried) {
+      excluded.push({ path, bytes: bytes.length, sha256: sha2562, rule: verdict.rule, reason: verdict.reason });
+      continue;
+    }
+    candidates.push({ path, bytes, sha256: sha2562, carries: verdict.carries, owned: verdict.owned });
+  }
+  const report = await findSessionTextLeaks({
+    viewDir: sourceDir,
+    sourceDir,
+    carriedPaths: candidates.map((candidate) => candidate.path),
+    excludedPaths: excluded.map((entry) => entry.path)
+  });
+  const leakByPath = new Map(report.leaks.map((leak) => [leak.viewPath, leak]));
+  const ownedLeak = report.leaks.find((leak) => candidates.some((c) => c.path === leak.viewPath && c.owned));
+  if (ownedLeak) {
+    throw new Error(
+      `${ownedLeak.viewPath} repeats ${ownedLeak.signatures} ${SIGNATURE_WORDS}-word run(s) found in ${ownedLeak.sources.join(", ")}, for example "${ownedLeak.example}". That artifact is derived by traces and must carry counts only, so this is a defect in the derivation, not a property of the session. No view was written.`
+    );
+  }
+  for (const candidate of candidates) {
+    const leak = leakByPath.get(candidate.path);
+    if (leak) {
+      excluded.push({
+        path: candidate.path,
+        bytes: candidate.bytes.length,
+        sha256: candidate.sha256,
+        rule: "content-signature",
+        reason: `the content check found ${leak.signatures} ${SIGNATURE_WORDS}-word run(s) this file shares with ${leak.sources.join(", ")}; carrying it would put back text the view removes`,
+        contentMatch: { signatures: leak.signatures, sources: leak.sources }
+      });
+      continue;
+    }
+    const target = join33(outDir, candidate.path);
+    await mkdir6(dirname9(target), { recursive: true });
+    await writeFile10(target, candidate.bytes);
+    carriedPaths.push(candidate.path);
+    carries.set(candidate.path, candidate.carries);
+  }
+  const leakCheck = {
+    signatureWords: SIGNATURE_WORDS,
+    comparedSources: report.comparedSources,
+    sourceSignatures: report.sourceSignatures,
+    carried: report.carried.filter((entry) => carries.has(entry.path)).map((entry) => ({
+      path: entry.path,
+      carries: carries.get(entry.path),
+      signatures: entry.signatures
+    })),
+    matches: 0
+  };
+  const sourceManifestBytes = await readFile15(join33(sourceDir, "manifest.json"));
+  const manifest = {
+    schemaVersion: 2,
+    kind: "traces.session_bundle",
+    view: "evidence-only",
+    createdAt: generatedAt,
+    provenance: source.provenance,
+    files: await hashSessionBundleFiles(outDir),
+    absent: source.absent,
+    excluded,
+    ledgerSlices: source.ledgerSlices.filter((slice) => carriedPaths.includes(slice.path)),
+    knownLimits: [...source.knownLimits, ...EVIDENCE_ONLY_LIMITS],
+    projection: {
+      sourceDirectory: sourceDir,
+      sourceManifestSha256: createHash15("sha256").update(sourceManifestBytes).digest("hex"),
+      leakCheck
+    }
+  };
+  const manifestPath = await writeSessionBundleManifest(outDir, manifest);
+  return { directory: outDir, manifestPath, manifest, leakCheck };
+}
+
 // src/upload-state.ts
-import { mkdir as mkdir5, readFile as readFile14, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile16, writeFile as writeFile11 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-import { dirname as dirname9, join as join32 } from "path";
+import { dirname as dirname10, join as join34 } from "path";
 import { contentHash } from "@tangle-network/agent-eval";
 function stateFile() {
-  const base = process.env.XDG_STATE_HOME ?? join32(homedir12(), ".local", "state");
-  return join32(base, "tangle-traces", "uploaded.json");
+  const base = process.env.XDG_STATE_HOME ?? join34(homedir12(), ".local", "state");
+  return join34(base, "tangle-traces", "uploaded.json");
 }
 function uploadKey(harness, sessionId) {
   return `${harness}:${sessionId}`;
@@ -15889,15 +17098,15 @@ function outboundHash(events, identity) {
 }
 async function loadState() {
   try {
-    return JSON.parse(await readFile14(stateFile(), "utf8"));
+    return JSON.parse(await readFile16(stateFile(), "utf8"));
   } catch {
     return {};
   }
 }
 async function saveState(state) {
   const f = stateFile();
-  await mkdir5(dirname9(f), { recursive: true });
-  await writeFile9(f, `${JSON.stringify(state, null, 2)}
+  await mkdir7(dirname10(f), { recursive: true });
+  await writeFile11(f, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
 function alreadyUploaded(state, harness, sessionId, hash2) {
@@ -15905,10 +17114,10 @@ function alreadyUploaded(state, harness, sessionId, hash2) {
 }
 
 // src/upload.ts
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
 import { hostname as hostname2 } from "os";
-import { basename as basename15, join as join33 } from "path";
+import { basename as basename15, join as join35 } from "path";
 import { hostedClientFromEnv } from "@tangle-network/agent-eval/hosted";
 import { REDACTION_VERSION } from "@tangle-network/agent-eval/traces";
 var require2 = createRequire2(import.meta.url);
@@ -15932,7 +17141,7 @@ async function planUpload(opts = {}) {
 async function gitBranch(cwd) {
   if (!cwd) return void 0;
   try {
-    const head = await readFile15(join33(cwd, ".git", "HEAD"), "utf8");
+    const head = await readFile17(join35(cwd, ".git", "HEAD"), "utf8");
     const m = head.match(/^ref:\s*refs\/heads\/(.+)$/m);
     return m?.[1]?.trim();
   } catch {
@@ -15941,16 +17150,16 @@ async function gitBranch(cwd) {
 }
 async function sessionMeta(item) {
   const meta = {
-    [ATTR2.HARNESS]: item.ref.harness,
-    [ATTR2.SESSION_FILE]: basename15(item.ref.path),
-    [ATTR2.HOST]: hostname2(),
-    [ATTR2.UPLOADER]: `tangle-traces@${TRACES_VERSION}`,
-    [ATTR2.REDACTION_VERSION]: REDACTION_VERSION,
-    [ATTR2.REDACTION_COUNT]: item.redaction.redactionCount
-  };
-  if (item.ref.cwd) meta[ATTR2.CWD] = item.ref.cwd;
+    [ATTR.HARNESS]: item.ref.harness,
+    [ATTR.SESSION_FILE]: basename15(item.ref.path),
+    [ATTR.HOST]: hostname2(),
+    [ATTR.UPLOADER]: `tangle-traces@${TRACES_VERSION}`,
+    [ATTR.REDACTION_VERSION]: REDACTION_VERSION,
+    [ATTR.REDACTION_COUNT]: item.redaction.redactionCount
+  };
+  if (item.ref.cwd) meta[ATTR.CWD] = item.ref.cwd;
   const branch = await gitBranch(item.ref.cwd);
-  if (branch) meta[ATTR2.GIT_BRANCH] = branch;
+  if (branch) meta[ATTR.GIT_BRANCH] = branch;
   return meta;
 }
 var msToNano = (epochMs) => (BigInt(epochMs) * 1000000n).toString();
@@ -15961,8 +17170,8 @@ function toTraceSpanEvents(spans, rootMeta) {
       if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") attributes2[k] = v;
       else if (v != null) attributes2[k] = JSON.stringify(v);
     }
-    attributes2[ATTR2.SESSION_ID] = s.trace_id;
-    attributes2[ATTR2.INGEST_SOURCE] = INGEST_SOURCE_CLI;
+    attributes2[ATTR.SESSION_ID] = s.trace_id;
+    attributes2[ATTR.INGEST_SOURCE] = INGEST_SOURCE_CLI;
     if (s.parent_span_id === null) Object.assign(attributes2, rootMeta);
     const startMs = parseIsoToEpochMs(s.start_time);
     const endMs = Math.max(startMs, parseIsoToEpochMs(s.end_time));
@@ -16021,7 +17230,7 @@ async function prepareOutbound(plan, opts, uploadedAt) {
     const key = uploadKey(item.ref.harness, item.ref.sessionId);
     const previous = plan.state[key];
     const meta = await sessionMeta(item);
-    const eventsAt = (timestamp) => toTraceSpanEvents(item.spans, { ...meta, [ATTR2.UPLOADED_AT]: timestamp });
+    const eventsAt = (timestamp) => toTraceSpanEvents(item.spans, { ...meta, [ATTR.UPLOADED_AT]: timestamp });
     let eventTimestamp2 = previous?.uploadedAt ?? uploadedAt;
     let events = eventsAt(eventTimestamp2);
     let hash2 = outboundHash(events, identity);
@@ -16099,6 +17308,15 @@ async function executeUpload(plan, opts = {}) {
 
 export {
   appendAll,
+  ATTR,
+  INGEST_SOURCE_CLI,
+  environmentAttributes,
+  stampEnvironmentAttrs,
+  environmentFromSpanAttributes,
+  DEFAULT_HARNESS,
+  sessionIdFromAttributes,
+  indexSessionIdsByTrace,
+  stampSessionIdentity,
   parseIsoToEpochMs,
   parseSince,
   resolveOtlpInputFiles,
@@ -16115,12 +17333,6 @@ export {
   capText,
   ACTOR_ATTR,
   userPromptSpan,
-  ATTR2 as ATTR,
-  INGEST_SOURCE_CLI,
-  DEFAULT_HARNESS,
-  sessionIdFromAttributes,
-  indexSessionIdsByTrace,
-  stampSessionIdentity,
   isChatTrajectoryMessage,
   isChatTrajectory,
   chatTrajectoryToSpans,
@@ -16173,6 +17385,7 @@ export {
   scanSessions,
   SessionWorkflowError,
   describeSessionRelationship,
+  POLICY_EVIDENCE_NOTE,
   buildPolicyEvidenceRecord,
   collectPolicyEvidence,
   serializePolicyEvidence,
@@ -16233,6 +17446,8 @@ export {
   commandRedactor,
   writeHodoscopeInput,
   hodoscopeAnalyzer,
+  httpJsonTransport,
+  primeAnalyzer,
   CODING_REDACTION_RULES,
   TRACES_REDACTION_RULES,
   redactSpans,
@@ -16263,7 +17478,7 @@ export {
   analyzeSteeringChain,
   REACTIONS,
   analyzeReactions,
-  CORRUPTION_RECEIPT_DISPLAY_LIMIT,
+  sessionReportSource,
   buildTraceFindingPacket,
   loadTracesConfig,
   mergeTracesConfig,
@@ -16320,10 +17535,20 @@ export {
   collectSessionWorkflow,
   collectSessionSelection,
   buildSessionIndex,
+  findContextRoot,
   buildSessionIndexFromRows,
   collectSessionIndex,
   serializeSessionIndex,
   writeSessionIndexFile,
+  listSessionBundleFiles,
+  assembleSessionBundle,
+  hashSessionBundleFiles,
+  writeSessionBundleManifest,
+  readSessionBundleManifest,
+  sessionTextSignatures,
+  findSessionTextLeaks,
+  classifyEvidenceOnlyPath,
+  projectSessionBundle,
   uploadKey,
   sessionHash,
   outboundHash,