@tangle-network/traces 0.16.3 → 0.17.0

package/dist/{chunk-G5KKIQZ6.js → chunk-4QY4U4XW.js}

@@ -9,13 +9,13 @@ function sourceFileId(path) {
 function pointerPart(value) {
   return value.replaceAll("~", "~0").replaceAll("/", "~1");
 }
-function locateSourceObjects(value, path, bytes, offset = 0) {
+function locateSourceObjects(value, path, bytes2, offset = 0) {
   if (!value || typeof value !== "object") return;
   const record2 = {
     sourceId: sourceFileId(path),
     recordOffset: offset,
-    recordBytes: bytes.length,
-    recordSha256: createHash("sha256").update(bytes).digest("hex")
+    recordBytes: bytes2.length,
+    recordSha256: createHash("sha256").update(bytes2).digest("hex")
   };
   const pending = [{ value, pointer: "#" }];
   while (pending.length > 0) {
@@ -317,35 +317,35 @@ function serialize(value) {
   return { value: canonicalJson(value), mimeType: "application/json" };
 }
 function utf8Prefix(value, maxBytes) {
-  let bytes = 0;
+  let bytes2 = 0;
   let end = 0;
   for (const char of value) {
     const charBytes = Buffer.byteLength(char);
-    if (bytes + charBytes > maxBytes) break;
-    bytes += charBytes;
+    if (bytes2 + charBytes > maxBytes) break;
+    bytes2 += charBytes;
     end += char.length;
   }
   return Buffer.from(value.slice(0, end), "utf8").toString("utf8");
 }
-function truncatedValue(value, bytes) {
+function truncatedValue(value, bytes2) {
   const longestMarker = `
-[truncated ${bytes} bytes]`;
+[truncated ${bytes2} bytes]`;
   const prefix = utf8Prefix(value, TOOL_IO_VALUE_MAX_BYTES - Buffer.byteLength(longestMarker));
-  const omittedBytes = bytes - Buffer.byteLength(prefix);
+  const omittedBytes = bytes2 - Buffer.byteLength(prefix);
   return `${prefix}
 [truncated ${omittedBytes} bytes]`;
 }
 function valueAttributes(side, raw) {
   const serialized = serialize(raw);
   if (!serialized) return {};
-  const bytes = Buffer.byteLength(serialized.value);
+  const bytes2 = Buffer.byteLength(serialized.value);
   const sha2562 = createHash2("sha256").update(serialized.value).digest("hex");
-  const truncated = bytes > TOOL_IO_VALUE_MAX_BYTES;
-  const value = truncated ? truncatedValue(serialized.value, bytes) : serialized.value;
+  const truncated = bytes2 > TOOL_IO_VALUE_MAX_BYTES;
+  const value = truncated ? truncatedValue(serialized.value, bytes2) : serialized.value;
   return {
     [`${side}.value`]: value,
     [`${side}.mime_type`]: serialized.mimeType,
-    [`traces.${side}.bytes`]: bytes,
+    [`traces.${side}.bytes`]: bytes2,
     [`traces.${side}.sha256`]: sha2562,
     [`traces.${side}.truncated`]: truncated
   };
@@ -1011,16 +1011,36 @@ function toOpenInferenceSpan(s) {
 }
 function serializeSpans(spans) {
   if (spans.length === 0) return "";
-  const validated = validateOtlpSpans(spans, "serialized spans");
-  return `${validated.map((s) => JSON.stringify(toOpenInferenceSpan(s))).join("\n")}
+  let out = "";
+  for (const line of iterSerializedSpans(spans)) out += line;
+  return out;
+}
+function* iterSerializedSpans(spans) {
+  for (const s of validateOtlpSpans(spans, "serialized spans")) {
+    yield `${JSON.stringify(toOpenInferenceSpan(s))}
 `;
+  }
 }
+var OTLP_WRITE_CHUNK_CHARS = 4 * 1024 * 1024;
 async function writeOtlpFile(spans, outPath) {
-  const { mkdtemp: mkdtemp8, writeFile: writeFile13 } = await import("fs/promises");
+  const { mkdtemp: mkdtemp8, open: open2 } = await import("fs/promises");
   const { tmpdir: tmpdir8 } = await import("os");
   const { join: join35 } = await import("path");
   const path = outPath ?? join35(await mkdtemp8(join35(tmpdir8(), "traces-")), "spans.otlp.jsonl");
-  await writeFile13(path, serializeSpans(spans), "utf8");
+  const handle = await open2(path, "w");
+  try {
+    let chunk = "";
+    for (const line of iterSerializedSpans(spans)) {
+      chunk += line;
+      if (chunk.length >= OTLP_WRITE_CHUNK_CHARS) {
+        await handle.write(chunk);
+        chunk = "";
+      }
+    }
+    if (chunk.length > 0) await handle.write(chunk);
+  } finally {
+    await handle.close();
+  }
   return path;
 }
 
@@ -1367,18 +1387,18 @@ function isMissingJsonSource(error) {
 }
 async function readJsonFile(path, options = {}) {
   let raw;
-  let bytes;
+  let bytes2;
   try {
     if (options.captureSources) {
-      bytes = await readFile3(path);
-      raw = bytes.toString("utf8");
+      bytes2 = await readFile3(path);
+      raw = bytes2.toString("utf8");
     } else raw = await readFile3(path, "utf8");
   } catch (error) {
     throw new JsonSourceError(path, "read", error);
   }
   try {
     const value = JSON.parse(raw);
-    if (bytes) locateSourceObjects(value, path, bytes);
+    if (bytes2) locateSourceObjects(value, path, bytes2);
     return value;
   } catch (error) {
     throw new JsonSourceError(path, "parse", pathSafeParseCause(error));
@@ -1585,9 +1605,9 @@ function parseLine(rawLine, path, lineNumber, byteOffset, options) {
   const jsonBytes = rawLine.at(-1) === 13 ? rawLine.subarray(0, -1) : rawLine;
   if (jsonBytes.length === 0) return void 0;
   if (!isUtf8(jsonBytes)) return handleCorruption(rawLine, path, lineNumber, byteOffset, options);
-  const json2 = jsonBytes.toString("utf8");
-  if (json2.trim().length === 0) return void 0;
   try {
+    const json2 = jsonBytes.toString("utf8");
+    if (json2.trim().length === 0) return void 0;
     const value = JSON.parse(json2);
     if (options.captureSources) locateSourceObjects(value, path, rawLine, byteOffset);
     return value;
@@ -1615,12 +1635,12 @@ async function* readJsonl(path, options = { mode: "strict" }) {
   try {
     for await (const chunk of input) {
       options.signal?.throwIfAborted();
-      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      const bytes2 = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
       let start = 0;
-      let newline = bytes.indexOf(10);
+      let newline = bytes2.indexOf(10);
       while (newline !== -1) {
         options.signal?.throwIfAborted();
-        fragments.push(bytes.subarray(start, newline));
+        fragments.push(bytes2.subarray(start, newline));
         const rawLine = fragments.length === 1 ? fragments[0] : Buffer.concat(fragments);
         fragments = [];
         lineNumber += 1;
@@ -1628,9 +1648,9 @@ async function* readJsonl(path, options = { mode: "strict" }) {
         if (parsed !== void 0) yield parsed;
         byteOffset += rawLine.length + 1;
         start = newline + 1;
-        newline = bytes.indexOf(10, start);
+        newline = bytes2.indexOf(10, start);
       }
-      if (start < bytes.length) fragments.push(bytes.subarray(start));
+      if (start < bytes2.length) fragments.push(bytes2.subarray(start));
     }
     if (fragments.length > 0) {
       options.signal?.throwIfAborted();
@@ -1814,7 +1834,7 @@ var CORRECTIVE_REACTIONS = ["correction", "frustration", "jargon", "structure"];
 import { createHash as createHash6 } from "crypto";
 import { readdir as readdir5, stat as stat3 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { basename as basename5, join as join5, relative as relative3 } from "path";
+import { basename as basename4, join as join5, relative as relative3 } from "path";
 import {
   applyLlmSpanOtlpAttributes as applyLlmSpanOtlpAttributes2,
   LLM_CACHED_TOKENS,
@@ -1827,7 +1847,7 @@ import { ATTR as ATTR3, deriveHexId as deriveHexId2 } from "@tangle-network/agen
 // src/adapters/claude-subagent-sources.ts
 import { readdir as readdir4, realpath } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { basename as basename4, dirname as dirname3, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve3 } from "path";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve3 } from "path";
 
 // src/adapters/claude-workflow.ts
 import { basename as basename3, dirname as dirname2, isAbsolute, relative, resolve as resolve2 } from "path";
@@ -1928,7 +1948,7 @@ function workflowRunIdForSubagent(subDir, file) {
   }
   return parts[1];
 }
-function bindWorkflowSubagent(file, runId, transcriptDir, bindings) {
+function bindWorkflowSubagent(file, runId, transcriptDir, bindings, sourceTranscriptDir = transcriptDir) {
   const runBindings = bindings.get(runId);
   if (!runBindings || runBindings.length === 0) {
     throw new ClaudeTaskScopeError(
@@ -1942,7 +1962,7 @@ function bindWorkflowSubagent(file, runId, transcriptDir, bindings) {
     );
   }
   const localBindings = runBindings.filter(
-    (binding) => resolve2(binding.transcriptDir) === expectedDir
+    (binding) => resolve2(binding.transcriptDir) === resolve2(sourceTranscriptDir)
   );
   if (localBindings.length === 0) {
     throw new ClaudeTaskScopeError(
@@ -1995,7 +2015,7 @@ function selectWorkflowBinding(file, bindings, childStartedAt, explicitToolUseId
 }
 
 // src/adapters/claude-subagent-sources.ts
-async function listSubagentFiles(root, signal) {
+async function listSubagentFiles(root, signal, copiedWorkflow = false) {
   const pending = [root];
   const files = [];
   while (pending.length > 0) {
@@ -2012,6 +2032,11 @@ async function listSubagentFiles(root, signal) {
     signal?.throwIfAborted();
     for (const entry of entries) {
       const path = join4(dir, entry.name);
+      if (copiedWorkflow && entry.isSymbolicLink()) {
+        throw new ClaudeTaskScopeError(
+          `Claude Workflow subagent does not match copied source: ${path}`
+        );
+      }
       if (entry.isDirectory()) {
         pending.push(path);
       } else if (entry.isFile() && /^agent-.*\.jsonl$/.test(entry.name)) {
@@ -2029,23 +2054,47 @@ function workflowStorageRoot(ref) {
   const nativeRoot = resolve3(homedir2(), ".claude", "projects");
   return pathIsWithin(nativeRoot, ref.path) ? nativeRoot : dirname3(resolve3(ref.path));
 }
+function relocatedWorkflowDirectory(ref, binding) {
+  const source = binding.transcriptDir;
+  if (resolve3(source) !== source || source.includes("\\")) return void 0;
+  const parts = source.split("/").slice(-7);
+  const sessionId = parts[3];
+  if (parts[0] !== ".claude" || parts[1] !== "projects" || !parts[2] || !sessionId || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId) || parts[4] !== "subagents" || parts[5] !== "workflows" || parts[6] !== binding.runId) return void 0;
+  const sessionRoot2 = join4(dirname3(resolve3(ref.path)), sessionId);
+  return {
+    sessionRoot: sessionRoot2,
+    transcriptDir: join4(sessionRoot2, "subagents", "workflows", binding.runId)
+  };
+}
 async function workflowTranscriptDirectories(ref, bindings) {
   const allowedRoot = workflowStorageRoot(ref);
   const allowedRealRoot = await realpath(allowedRoot);
   const directories = /* @__PURE__ */ new Map();
   for (const runBindings of bindings.values()) {
     for (const binding of runBindings) {
-      const directory = resolve3(binding.transcriptDir);
+      let directory = resolve3(binding.transcriptDir);
+      let relocation;
       if (!pathIsWithin(allowedRoot, directory)) {
-        throw new ClaudeTaskScopeError(
-          `Claude Workflow transcript directory escapes ${allowedRoot}: ${directory}`
-        );
+        relocation = relocatedWorkflowDirectory(ref, binding);
+        if (!relocation || !pathIsWithin(allowedRoot, relocation.transcriptDir)) {
+          throw new ClaudeTaskScopeError(
+            `Claude Workflow transcript directory escapes ${allowedRoot}: ${directory}`
+          );
+        }
+        directory = relocation.transcriptDir;
       }
       let realDirectory;
       try {
         realDirectory = await realpath(directory);
       } catch (error) {
-        if (isMissingPathError(error)) continue;
+        if (isMissingPathError(error)) {
+          if (relocation) {
+            throw new ClaudeTaskScopeError(
+              `Cannot relocate Claude Workflow run ${binding.runId}: copied transcript directory is missing: ${directory}`
+            );
+          }
+          continue;
+        }
         throw error;
       }
       if (!pathIsWithin(allowedRealRoot, realDirectory)) {
@@ -2053,10 +2102,38 @@ async function workflowTranscriptDirectories(ref, bindings) {
           `Claude Workflow transcript directory escapes ${allowedRoot}: ${directory}`
         );
       }
-      directories.set(realDirectory, directory);
+      if (relocation) {
+        const copiedRoot = dirname3(resolve3(ref.path));
+        const copiedRealRoot = await realpath(copiedRoot);
+        const sessionRealRoot = await realpath(relocation.sessionRoot);
+        const expectedSessionRealRoot = resolve3(
+          copiedRealRoot,
+          relative2(copiedRoot, relocation.sessionRoot)
+        );
+        const expectedRealDirectory = resolve3(copiedRealRoot, relative2(copiedRoot, directory));
+        if (sessionRealRoot !== expectedSessionRealRoot || realDirectory !== expectedRealDirectory) {
+          throw new ClaudeTaskScopeError(
+            `Claude Workflow transcript directory does not match copied session subtree ${relocation.sessionRoot}: ${directory}`
+          );
+        }
+      }
+      const previous = directories.get(realDirectory);
+      if (previous && (previous.runId !== binding.runId || resolve3(previous.sourceTranscriptDir ?? previous.transcriptDir) !== resolve3(binding.transcriptDir))) {
+        throw new ClaudeTaskScopeError(
+          `Claude Workflow transcript directory ${directory} has conflicting source bindings`
+        );
+      }
+      directories.set(realDirectory, {
+        runId: binding.runId,
+        transcriptDir: directory,
+        sourceTranscriptDir: binding.transcriptDir,
+        ...relocation ? { copiedWorkflow: true } : {}
+      });
     }
   }
-  return [...directories.values()].sort();
+  return [...directories.values()].sort(
+    (left, right) => left.transcriptDir.localeCompare(right.transcriptDir)
+  );
 }
 async function collectClaudeSubagentSources(ref, bindings, signal) {
   const subDir = join4(ref.path.replace(/\.jsonl$/, ""), "subagents");
@@ -2073,10 +2150,11 @@ async function collectClaudeSubagentSources(ref, bindings, signal) {
       });
     }
   }
-  for (const transcriptDir of await workflowTranscriptDirectories(ref, bindings)) {
+  for (const location of await workflowTranscriptDirectories(ref, bindings)) {
     signal?.throwIfAborted();
-    const runId = basename4(transcriptDir);
-    for (const file of await listSubagentFiles(transcriptDir, signal)) {
+    const { runId, transcriptDir } = location;
+    const files2 = await listSubagentFiles(transcriptDir, signal, location.copiedWorkflow);
+    for (const file of files2) {
       const path = resolve3(file);
       filesByPath.set(path, file);
       const previous = workflowByPath.get(path);
@@ -2085,7 +2163,7 @@ async function collectClaudeSubagentSources(ref, bindings, signal) {
           `Claude Workflow subagent ${file} belongs to multiple transcript directories`
         );
       }
-      workflowByPath.set(path, { runId, transcriptDir });
+      workflowByPath.set(path, location);
     }
   }
   const files = [...filesByPath.values()].sort();
@@ -2171,6 +2249,7 @@ function createClaudeStream(startStep) {
     step: startStep,
     sawUserTurn: false,
     promptSpans: [],
+    promptSpanByUid: /* @__PURE__ */ new Map(),
     sawRecordedOrigin: false,
     firstRecordAt: null,
     lastRecordAt: null
@@ -2203,6 +2282,9 @@ function projectToolResult(toolUseId, isError, output, structuredWorkflowRun, ou
 }
 function projectClaudeEvent(event) {
   const timestamp = event.timestamp ?? EPOCH;
+  if (event.type === "system" && event.subtype === "compact_boundary") {
+    return { kind: "compaction", timestamp: event.timestamp ?? "", metadata: event.compactMetadata ?? {}, parentToolUseId: event.parent_tool_use_id };
+  }
   if (event.type === "assistant" && event.message) {
     const tools = [];
     for (const block of asBlocks(event.message.content)) {
@@ -2344,7 +2426,7 @@ function indexWorkflowProjection(projection, index) {
 function fingerprintClaudeEvent(event) {
   return createHash6("sha256").update(JSON.stringify(
     event,
-    (key, value) => key === "contentSource" || key.startsWith(SOURCE_ATTRIBUTE_PREFIX) ? void 0 : value
+    (key, value) => key === "contentSource" || key === "originKind" || key.startsWith(SOURCE_ATTRIBUTE_PREFIX) ? void 0 : value
   )).digest("hex");
 }
 function startsClaudeTask(projection) {
@@ -2358,21 +2440,43 @@ function startsClaudeTask(projection) {
 function distinctClaudeEvent(event, seen, sourcePath, fallbackUid) {
   const projection = projectClaudeEvent(event);
   if (event.uuid) {
+    const uid = event.uuid;
     const fingerprint = fingerprintClaudeEvent(projection);
-    const previous = seen.get(event.uuid);
-    if (previous !== void 0) {
-      if (previous !== fingerprint) {
-        throw new ClaudeEventConflictError(sourcePath, event.uuid);
+    const originKind = (projection.kind === "user" || projection.kind === "queued-prompt" ? projection.originKind : null) ?? null;
+    const previous = seen.get(uid);
+    if (previous) {
+      if (previous.fingerprint !== fingerprint) {
+        throw new ClaudeEventConflictError(sourcePath, uid);
+      }
+      if (previous.originKind === null && originKind !== null) return { originEnrichment: originKind, uid };
+      if (previous.originKind !== null && originKind !== null && previous.originKind !== originKind) {
+        throw new ClaudeEventConflictError(sourcePath, uid);
       }
       return void 0;
     }
-    seen.set(event.uuid, fingerprint);
+    seen.set(uid, { fingerprint, originKind });
   }
   return { projection, uid: event.uuid ?? fallbackUid };
 }
+function applyOriginEnrichment(uid, originKind, state) {
+  const prompt = state.promptSpanByUid.get(uid);
+  if (!prompt) return;
+  if (prompt.attributes[ORIGIN_RECORDED_ATTR] === true) return;
+  state.sawRecordedOrigin = true;
+  prompt.attributes[ORIGIN_RECORDED_ATTR] = true;
+  prompt.attributes[ORIGIN_KIND_ATTR] = originKind;
+  prompt.attributes[ACTOR_ATTR] = claudeActorFromOrigin(
+    originKind,
+    () => prompt.attributes[ACTOR_ATTR]
+  );
+}
 function consumeDistinctClaudeEvent(event, ctx, state, seen, sourcePath) {
   const accepted = distinctClaudeEvent(event, seen, sourcePath, `step${state.step}`);
   if (!accepted) return false;
+  if ("originEnrichment" in accepted) {
+    applyOriginEnrichment(accepted.uid, accepted.originEnrichment, state);
+    return false;
+  }
   consumeClaudeEvent(accepted.projection, accepted.uid, ctx, state);
   return true;
 }
@@ -2382,6 +2486,34 @@ function inStreamParent(parentToolUseId, state) {
   return parentTool ? { span: parentTool, confidence: "explicit" } : void 0;
 }
 function consumeClaudeEvent(event, uid, ctx, state) {
+  if (event.kind === "compaction") {
+    const extra = {};
+    const numericFields = {
+      preTokens: "traces.compaction.tokens_before",
+      postTokens: "traces.compaction.tokens_after",
+      durationMs: "traces.compaction.latency_ms",
+      cumulativeDroppedTokens: "traces.compaction.cumulative_dropped_tokens"
+    };
+    for (const [field, key] of Object.entries(numericFields)) {
+      const value = event.metadata[field];
+      if (typeof value === "number" && Number.isFinite(value) && value >= 0) extra[key] = value;
+    }
+    if (typeof event.metadata.trigger === "string") extra["traces.compaction.trigger"] = event.metadata.trigger;
+    const parent = inStreamParent(event.parentToolUseId, state);
+    state.spans.push(span({
+      traceId: ctx.traceId,
+      spanId: ctx.idPrefix + uid + ":compacted",
+      parentSpanId: parent ? parent.span.span_id : ctx.rootParent,
+      name: "session.compacted",
+      kind: "CHAIN",
+      startTime: event.timestamp,
+      service: SERVICE2,
+      agent: ctx.agent,
+      step: state.step++,
+      extra
+    }));
+    return;
+  }
   if (event.kind === "assistant") {
     const messageId = event.messageId ?? uid;
     let llmSpan = state.llmSpanByMessageId.get(messageId);
@@ -2495,6 +2627,7 @@ function consumeClaudeEvent(event, uid, ctx, state) {
       if (userParent) prompt.attributes[ATTR3.parentConfidence] = userParent.confidence;
       state.spans.push(prompt);
       state.promptSpans.push(prompt);
+      state.promptSpanByUid.set(uid, prompt);
       state.step += 1;
     }
     for (const result of event.results) {
@@ -2524,6 +2657,7 @@ function consumeClaudeEvent(event, uid, ctx, state) {
     }
     state.spans.push(prompt);
     state.promptSpans.push(prompt);
+    state.promptSpanByUid.set(uid, prompt);
     state.step += 1;
   } else if (event.kind === "file-change") {
     state.spans.push(span({
@@ -2685,7 +2819,7 @@ async function readClaudeWorkflowBindings(ref, options) {
     options.signal?.throwIfAborted();
     const accepted = distinctClaudeEvent(event, seen, ref.path, `source${row}`);
     row += 1;
-    if (accepted) indexWorkflowProjection(accepted.projection, index);
+    if (accepted && "projection" in accepted) indexWorkflowProjection(accepted.projection, index);
   }
   return bindWorkflowRuns(index);
 }
@@ -2794,7 +2928,7 @@ var ClaudeAdapter = class {
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
         const cwd = `/${dir.replace(/^-/, "").replace(/-/g, "/")}`;
         if (opts.cwd && !cwd.startsWith(opts.cwd)) continue;
-        refs.push({ harness: this.harness, sessionId: basename5(f, ".jsonl"), path, cwd, mtimeMs: st.mtimeMs });
+        refs.push({ harness: this.harness, sessionId: basename4(f, ".jsonl"), path, cwd, mtimeMs: st.mtimeMs });
       }
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -2837,7 +2971,10 @@ var ClaudeAdapter = class {
         runResult = { failed: event.is_error, subtype: event.subtype ?? "unknown" };
       }
       const accepted = distinctClaudeEvent(event, seen, ref.path, `step${state.step}`);
-      if (!accepted) continue;
+      if (!accepted || "originEnrichment" in accepted) {
+        if (accepted) applyOriginEnrichment(accepted.uid, accepted.originEnrichment, state);
+        continue;
+      }
       indexWorkflowProjection(accepted.projection, workflowIndex);
       const startsTask = startsClaudeTask(accepted.projection);
       if (startsTask && taskScope === "latest") {
@@ -2945,7 +3082,7 @@ var ClaudeAdapter = class {
       const agent = {
         file,
         sourceKey,
-        agentId: basename5(file, ".jsonl").replace(/^agent-/, ""),
+        agentId: basename4(file, ".jsonl").replace(/^agent-/, ""),
         meta,
         ...meta.toolUseId ? { parentToolUseId: meta.toolUseId } : {}
       };
@@ -2954,11 +3091,12 @@ var ClaudeAdapter = class {
           file,
           workflowRunId,
           workflowLocation.transcriptDir,
-          workflowBindings
+          workflowBindings,
+          workflowLocation.sourceTranscriptDir
         );
         const parsed = await parseClaudeSubagent(ref, traceId, agent, options);
         const { binding, confidence } = selectWorkflowBinding(
-          basename5(file),
+          basename4(file),
           runBindings,
           firstSubagentTimestamp(agent, parsed),
           meta.toolUseId
@@ -3527,7 +3665,7 @@ async function resolveCodexParentTask(ref, childSessionId, options = {}) {
 // src/adapters/codex.ts
 import { readdir as readdir6, stat as stat4 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { basename as basename6, join as join6 } from "path";
+import { basename as basename5, join as join6 } from "path";
 import { deriveHexId as deriveHexId3 } from "@tangle-network/agent-trace-contract";
 var SERVICE3 = "codex";
 var SESSION_HEAD_LINES = 40;
@@ -3999,7 +4137,7 @@ var CodexAdapter = class {
     }
     if (opts.sinceMs && st.mtimeMs < opts.sinceMs) return void 0;
     let cwd = null;
-    let id = basename6(path).replace(/^rollout-[\dT-]+-/, "").replace(/\.jsonl$/, "");
+    let id = basename5(path).replace(/^rollout-[\dT-]+-/, "").replace(/\.jsonl$/, "");
     const ref = { harness: this.harness, sessionId: id, path, cwd, mtimeMs: st.mtimeMs };
     const head = await takeJsonl(path, SESSION_HEAD_LINES, sessionJsonlOptions(ref));
     for (const parsed of head) {
@@ -4027,7 +4165,7 @@ var CodexAdapter = class {
   async locateBySessionId(sessionId, opts = {}) {
     const refs = [];
     for await (const path of walkRollouts(this.root())) {
-      if (!basename6(path).includes(sessionId)) continue;
+      if (!basename5(path).includes(sessionId)) continue;
       const ref = await this.refFromPath(path, opts);
       if (ref?.sessionId === sessionId) refs.push(ref);
     }
@@ -4242,12 +4380,12 @@ var CodexAdapter = class {
       spans.push(turnSpan);
       step += 1;
     };
-    const recordInheritedContext = (l, ts) => {
+    const recordInheritedContext = (l, ts, inScope = false) => {
       if (l.type === "compacted") {
         const payload = l.payload;
         if (!payload) return;
         const summary = capText(typeof payload.message === "string" ? payload.message : "");
-        if (summary && claimInheritedSpan()) {
+        if (claimInheritedSpan()) {
           spans.push(span({
             traceId,
             spanId: `inherited:${step}:compacted`,
@@ -4262,7 +4400,7 @@ var CodexAdapter = class {
             contentSource: textSources(payload, "message"),
             extra: {
               [INHERITED_SPAN_ATTR]: true,
-              [INHERITED_SOURCE_ATTR]: "compacted",
+              [INHERITED_SOURCE_ATTR]: inScope ? "compacted" : "pre-task-prefix",
               ...typeof payload.window_number === "number" ? { "traces.codex.compaction_window_number": payload.window_number } : {},
               ...payload.window_id ? { "traces.codex.compaction_window_id": payload.window_id } : {},
               ...payload.previous_window_id ? { "traces.codex.compaction_previous_window_id": payload.previous_window_id } : {}
@@ -4436,7 +4574,7 @@ var CodexAdapter = class {
           step += 1;
         }
       } else if (l.type === "compacted") {
-        recordInheritedContext(l, ts);
+        recordInheritedContext(l, ts, true);
       } else if (l.type === "response_item" && (l.payload?.type === "function_call" || l.payload?.type === "custom_tool_call")) {
         const outerName = l.payload.name ?? "tool";
         const callId = l.payload.call_id ?? `${step}`;
@@ -5276,7 +5414,7 @@ var CopilotAdapter = class {
 // src/adapters/factory.ts
 import { readdir as readdir8, stat as stat6 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { basename as basename7, join as join8 } from "path";
+import { basename as basename6, join as join8 } from "path";
 var SERVICE6 = "factory";
 function textOf4(content) {
   return capText(
@@ -5321,7 +5459,7 @@ var FactoryAdapter = class {
           throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
-        refs.push({ harness: this.harness, sessionId: basename7(f, ".jsonl"), path, cwd, mtimeMs: st.mtimeMs });
+        refs.push({ harness: this.harness, sessionId: basename6(f, ".jsonl"), path, cwd, mtimeMs: st.mtimeMs });
       }
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -5460,7 +5598,7 @@ var FactoryAdapter = class {
 // src/adapters/forge.ts
 import { readdir as readdir9, stat as stat7 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { basename as basename8, join as join9 } from "path";
+import { basename as basename7, join as join9 } from "path";
 var SERVICE7 = "forge";
 function tokens(t) {
   if (!t) return null;
@@ -5498,7 +5636,7 @@ var ForgeAdapter = class {
           throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
-        refs.push({ harness: this.harness, sessionId: basename8(f, ".json"), path, cwd: dir, mtimeMs: st.mtimeMs });
+        refs.push({ harness: this.harness, sessionId: basename7(f, ".json"), path, cwd: dir, mtimeMs: st.mtimeMs });
       }
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -5960,7 +6098,7 @@ var OpencodeAdapter = class {
 // src/adapters/pi.ts
 import { readdir as readdir12, stat as stat10 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { basename as basename9, join as join12, resolve as resolve4 } from "path";
+import { basename as basename8, join as join12, resolve as resolve4 } from "path";
 var SERVICE9 = "pi";
 function terminalStatus(message) {
   const stopReason = message?.stopReason ?? "missing";
@@ -6042,7 +6180,7 @@ var PiAdapter = class {
     }
     const refs = [];
     for (const path of paths) {
-      const f = basename9(path);
+      const f = basename8(path);
       let st;
       try {
         st = await stat10(path);
@@ -6051,7 +6189,7 @@ var PiAdapter = class {
         throw error;
       }
       if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
-      let id = basename9(f, ".jsonl").replace(/^[\dTZ.-]+_/, "");
+      let id = basename8(f, ".jsonl").replace(/^[\dTZ.-]+_/, "");
       let cwd = null;
       const ref = {
         harness: this.harness,
@@ -6099,6 +6237,27 @@ var PiAdapter = class {
       if (!sessionLine && l.type === "session") {
         sessionLine = { id: l.id, timestamp: l.timestamp };
       }
+      if (l.type === "compaction") {
+        spans.push(span({
+          traceId: sourceTraceId,
+          spanId: "compacted:" + (l.id ?? step),
+          parentSpanId: sourceRootId,
+          name: "session.compacted",
+          kind: "CHAIN",
+          service: SERVICE9,
+          agent: SERVICE9,
+          startTime: l.timestamp ?? "",
+          step: step++,
+          content: typeof l.summary === "string" ? capText(l.summary) : void 0,
+          contentSource: sourceOf(l, "summary"),
+          extra: {
+            ...typeof l.tokensBefore === "number" && Number.isFinite(l.tokensBefore) && l.tokensBefore >= 0 ? { "traces.compaction.tokens_before": l.tokensBefore } : {},
+            ...typeof l.firstKeptEntryId === "string" ? { "traces.pi.first_kept_entry_id": l.firstKeptEntryId } : {},
+            ...l.systemMessage !== void 0 ? { "gen_ai.system_instructions": JSON.stringify(l.systemMessage) } : {}
+          }
+        }));
+        continue;
+      }
       if (l.type !== "message" || !l.message) continue;
       const ts = l.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
       const mid = l.id ?? `m${step}`;
@@ -6263,7 +6422,7 @@ var PiAdapter = class {
 // src/adapters/qwen.ts
 import { readdir as readdir13, stat as stat11 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { basename as basename10, join as join13 } from "path";
+import { basename as basename9, join as join13 } from "path";
 var SERVICE10 = "qwen";
 function textOf9(parts) {
   if (!parts) return "";
@@ -6306,7 +6465,7 @@ var QwenAdapter = class {
           throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
-        refs.push({ harness: this.harness, sessionId: basename10(f, ".jsonl"), path, cwd: null, mtimeMs: st.mtimeMs });
+        refs.push({ harness: this.harness, sessionId: basename9(f, ".jsonl"), path, cwd: null, mtimeMs: st.mtimeMs });
       }
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -6719,7 +6878,7 @@ function extractAbsolutePaths(spans) {
 async function resolveRepoAttrs(cwd) {
   if (!cwd) return {};
   const attrs = { [ATTR.CWD]: cwd };
-  const basename19 = (() => {
+  const basename18 = (() => {
     const trimmed = cwd.replace(/\/+$/g, "");
     const idx = trimmed.lastIndexOf("/");
     const name = idx === -1 ? trimmed : trimmed.slice(idx + 1);
@@ -6741,7 +6900,7 @@ async function resolveRepoAttrs(cwd) {
     if (commit) attrs[ATTR.GIT_COMMIT] = commit;
   } catch {
   }
-  attrs[ATTR.SUBJECT_KEY] = basename19;
+  attrs[ATTR.SUBJECT_KEY] = basename18;
   return attrs;
 }
 async function repoCandidateForPath(path) {
@@ -7336,7 +7495,7 @@ async function readLoopRuns(cwds, sessionIds) {
   }
   return { linkedCounts, unlinkedCounts, filesRead };
 }
-async function analyzeAdoption(spans, opts = {}) {
+function computeAdoption(spans) {
   const { sessionByTrace, conflicts } = indexSessionIdsByTrace(spans);
   const identifiedSessions = new Set(sessionByTrace.values());
   const unassignedTraceIds = new Set(
@@ -7393,11 +7552,9 @@ async function analyzeAdoption(spans, opts = {}) {
       subagentSpawns[type] = (subagentSpawns[type] ?? 0) + 1;
     }
   }
-  const {
-    linkedCounts: loopDispatchedRuns,
-    unlinkedCounts: unlinkedLoopDispatchedRuns,
-    filesRead
-  } = await readLoopRuns(opts.cwds ?? [], identifiedSessions);
+  const loopDispatchedRuns = {};
+  const unlinkedLoopDispatchedRuns = {};
+  const filesRead = 0;
   const totalSkillInvocations = Object.values(skillInvocations).reduce((a, b) => a + b, 0);
   const totalSkillDocumentReads = Object.values(skillDocumentReads).reduce((a, b) => a + b, 0);
   const totalSubagentSpawns = Object.values(subagentSpawns).reduce((a, b) => a + b, 0);
@@ -7441,6 +7598,19 @@ async function analyzeAdoption(spans, opts = {}) {
     totalUnlinkedLoopDispatchedRuns
   };
 }
+async function analyzeAdoption(spans, opts = {}) {
+  const report = computeAdoption(spans);
+  const { sessionByTrace } = indexSessionIdsByTrace(spans);
+  const history = await readLoopRuns(opts.cwds ?? [], new Set(sessionByTrace.values()));
+  return {
+    ...report,
+    loopDispatchedRuns: history.linkedCounts,
+    totalLoopDispatchedRuns: Object.values(history.linkedCounts).reduce((sum, count2) => sum + count2, 0),
+    unlinkedLoopDispatchedRuns: history.unlinkedCounts,
+    totalUnlinkedLoopDispatchedRuns: Object.values(history.unlinkedCounts).reduce((sum, count2) => sum + count2, 0),
+    skillRunFilesRead: history.filesRead
+  };
+}
 
 // src/agentic-routing.ts
 import {
@@ -7933,7 +8103,7 @@ var COMMAND_PREFIXES = /* @__PURE__ */ new Set([
 var ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
 var MAX_SHELL_DEPTH = 4;
 var MAX_WORDS = 2e4;
-function basename11(word) {
+function basename10(word) {
   const cut = word.lastIndexOf("/");
   return cut === -1 ? word : word.slice(cut + 1);
 }
@@ -8032,7 +8202,7 @@ var ShellScanner = class {
     let start = 0;
     while (start < words.length) {
       const word = words[start];
-      if (ASSIGNMENT.test(word) || COMMAND_PREFIXES.has(basename11(word))) start += 1;
+      if (ASSIGNMENT.test(word) || COMMAND_PREFIXES.has(basename10(word))) start += 1;
       else break;
     }
     return start === 0 || start >= words.length ? words : words.slice(start);
@@ -8173,7 +8343,7 @@ function shellCommands(script, depth = 0) {
   const out = [];
   for (const words of commands) {
     out.push(words);
-    const name = basename11(words[0] ?? "");
+    const name = basename10(words[0] ?? "");
     if (!SHELLS.has(name) || depth >= MAX_SHELL_DEPTH) continue;
     for (let index = 1; index < words.length; index += 1) {
       const word = words[index];
@@ -8201,7 +8371,7 @@ function commandTextFromInput(input) {
   if (!Array.isArray(value) || value.length === 0) return void 0;
   const words = value.filter((entry) => typeof entry === "string");
   if (words.length !== value.length) return void 0;
-  const head = basename11(words[0] ?? "");
+  const head = basename10(words[0] ?? "");
   if (SHELLS.has(head)) {
     const flag = words.findIndex((word, position) => position > 0 && /^-[a-z]*c$/.test(word));
     if (flag !== -1 && words[flag + 1] !== void 0) return words[flag + 1];
@@ -8263,7 +8433,7 @@ function stringAttribute2(span2, key) {
   const value = span2.attributes[key];
   return typeof value === "string" ? value : null;
 }
-function basename12(word) {
+function basename11(word) {
   const cut = word.lastIndexOf("/");
   return cut === -1 ? word : word.slice(cut + 1);
 }
@@ -8346,7 +8516,7 @@ function numbersInLine(line) {
 function inferHeadBranch(commands, upTo, output) {
   for (let index = upTo - 1; index >= 0; index -= 1) {
     const words = commands[index];
-    if (basename12(words[0] ?? "") !== "git" || words.length < 2) continue;
+    if (basename11(words[0] ?? "") !== "git" || words.length < 2) continue;
     const sub = words[1];
     const rest = words.slice(2);
     if (sub === "push") {
@@ -8399,13 +8569,13 @@ function mergeEvent(record2, recordIndex, words) {
   const target = positional[0] ?? null;
   const numberInCommand = target === null ? null : /^#?(\d+)$/.exec(target)?.[1] ?? numbersInLine(target)[0] ?? null;
   const numberInOutput = numberInCommand === null ? MERGED_NUMBER.exec(record2.output)?.[1] ?? null : null;
-  const number = numberInCommand ?? numberInOutput;
-  if (!reachedGh(record2, "merge", number !== null)) return null;
+  const number2 = numberInCommand ?? numberInOutput;
+  if (!reachedGh(record2, "merge", number2 !== null)) return null;
   const evidence3 = numberInCommand !== null ? "the pull request the command names" : numberInOutput !== null ? `the merge line this command printed, in span ${record2.spanId}` : target !== null ? "the branch the command names; no output that joins to it stated a number" : "none: the command named neither a pull request nor a branch";
   return {
     action: "merge",
-    number,
-    headBranch: number === null ? target : null,
+    number: number2,
+    headBranch: number2 === null ? target : null,
     command: words.join(" "),
     evidence: evidence3,
     spanIds: [record2.spanId],
@@ -8421,7 +8591,7 @@ function eventsFromRecord(record2, recordIndex) {
   let createIndex = 0;
   for (let index = 0; index < commands.length; index += 1) {
     const words = commands[index];
-    if (words.length < 3 || !GH_NAMES.has(basename12(words[0])) || words[1] !== "pr") continue;
+    if (words.length < 3 || !GH_NAMES.has(basename11(words[0])) || words[1] !== "pr") continue;
     const action = words[2];
     if (action === "create") {
       const printedNumber = printed[createIndex] ?? null;
@@ -8444,7 +8614,7 @@ function numberFromLaterOutput(records, after, headBranch) {
 ${record2.output}`.split("\n")) {
       const line = raw.replace(ANSI, "");
       if (!line.includes(headBranch)) continue;
-      for (const number of numbersInLine(line)) found.add(number);
+      for (const number2 of numbersInLine(line)) found.add(number2);
     }
     if (found.size === 1) return { number: [...found][0], spanId: record2.spanId };
   }
@@ -8533,9 +8703,144 @@ function readPullRequests(spans) {
   };
 }
 
+// src/session-facts.ts
+import { createHash as createHash7 } from "crypto";
+
+// src/session-measurements.ts
+var number = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+function measure(spans, read, reason) {
+  let total = 0;
+  let measured2 = 0;
+  for (const span2 of spans) {
+    const value = read(span2);
+    if (value !== null) {
+      total += value;
+      measured2 += 1;
+    }
+  }
+  return {
+    total: measured2 > 0 || spans.length === 0 ? total : null,
+    measured: measured2,
+    eligible: spans.length,
+    unavailable: measured2 === spans.length ? null : reason
+  };
+}
+function bytes(span2, side) {
+  const recorded = number(span2.attributes[`traces.${side}.bytes`]);
+  if (recorded !== null) return recorded;
+  const text2 = span2.attributes[`${side}.value`];
+  if (typeof text2 !== "string" || span2.attributes[`traces.${side}.truncated`] === true) return null;
+  return Buffer.byteLength(text2);
+}
+function toolMeasurements(tools) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const name = typeof tool.attributes["tool.name"] === "string" ? tool.attributes["tool.name"] : tool.name;
+    const group = groups.get(name);
+    if (group) group.push(tool);
+    else groups.set(name, [tool]);
+  }
+  return [...groups].sort(([a], [b]) => a.localeCompare(b)).map(([name, spans]) => ({
+    name,
+    calls: spans.length,
+    outcomes: {
+      ok: spans.filter((span2) => span2.status.code === "OK").length,
+      error: spans.filter((span2) => span2.status.code === "ERROR").length,
+      unset: spans.filter((span2) => span2.status.code === "UNSET").length
+    },
+    inputBytes: measure(spans, (span2) => bytes(span2, "input"), "Input byte count missing or truncated without a size receipt."),
+    outputBytes: measure(spans, (span2) => bytes(span2, "output"), "Output byte count missing or truncated without a size receipt."),
+    callToResultMs: measure(spans, (span2) => {
+      if (span2.status.code === "UNSET") return null;
+      const elapsed2 = Date.parse(span2.end_time) - Date.parse(span2.start_time);
+      return Number.isFinite(elapsed2) && elapsed2 > 0 ? elapsed2 : null;
+    }, "A completed span with distinct recorded endpoints is required; equal endpoints may be an adapter default."),
+    spanIds: spans.map((span2) => span2.span_id)
+  }));
+}
+function compactions(spans) {
+  const events = spans.filter((span2) => span2.name === "session.compacted" && span2.attributes[INHERITED_SOURCE_ATTR] !== "pre-task-prefix").sort((a, b) => Date.parse(a.start_time) - Date.parse(b.start_time));
+  if (events.length === 0) return {
+    value: null,
+    spanIds: [],
+    unavailable: "No compaction boundary was captured. This does not establish that no compaction occurred."
+  };
+  return {
+    value: events.map((span2, i) => {
+      const previous = i > 0 ? events[i - 1] : void 0;
+      const interval = previous ? Date.parse(span2.start_time) - Date.parse(previous.start_time) : NaN;
+      return {
+        spanId: span2.span_id,
+        at: span2.start_time,
+        sincePreviousMs: Number.isFinite(interval) && interval >= 0 ? interval : null,
+        latencyMs: number(span2.attributes["traces.compaction.latency_ms"]),
+        tokensBefore: number(span2.attributes["traces.compaction.tokens_before"]),
+        tokensAfter: number(span2.attributes["traces.compaction.tokens_after"])
+      };
+    }),
+    spanIds: events.map((span2) => span2.span_id),
+    unavailable: null,
+    partial: "Observed boundaries only. Latency and context sizes are null unless the source explicitly records them."
+  };
+}
+function contextFootprints(spans) {
+  const out = [];
+  for (const span2 of spans) {
+    const fields = ["gen_ai.tool.definitions", "gen_ai.system_instructions"];
+    if (span2.name === "message.system" || span2.name === "message.developer" || span2.name === "user.prompt" && span2.attributes["tangle.actor"] === "injected") fields.push("content");
+    for (const field of fields) {
+      const value = span2.attributes[field];
+      if (value === void 0 || value === null) continue;
+      const text2 = typeof value === "string" ? value : canonicalJson(value);
+      let entries = Array.isArray(value) ? value.length : null;
+      if (typeof value === "string") {
+        try {
+          const parsed = JSON.parse(value);
+          if (Array.isArray(parsed)) entries = parsed.length;
+        } catch {
+        }
+      }
+      out.push({ spanId: span2.span_id, field, bytes: Buffer.byteLength(text2), lines: text2.split("\n").length, entries, scope: "captured-attribute" });
+    }
+  }
+  return out;
+}
+function computeSessionMeasurements(spans, tools, sessionId, harness) {
+  const spawns = tools.filter((span2) => span2.attributes["traces.agent.spawn"] === true || span2.attributes["traces.codex.agent_operation"] === "spawn_agent").sort((a, b) => Date.parse(a.start_time) - Date.parse(b.start_time));
+  return {
+    observedSpawns: spawns.length,
+    spawnIntervalsMs: spawns.map((span2, i) => {
+      const previous = spawns[i - 1];
+      const interval = previous ? Date.parse(span2.start_time) - Date.parse(previous.start_time) : NaN;
+      return { spanId: span2.span_id, intervalMs: Number.isFinite(interval) && interval >= 0 ? interval : null };
+    }),
+    execution: spans.length > 0 ? summarizeSpanExecution(spans) : null,
+    adoption: computeAdoption(spans),
+    relationship: describeSessionRelationship({
+      sessionId: sessionId ?? spans[0]?.trace_id ?? "",
+      harness: harness ?? "",
+      path: "",
+      cwd: null,
+      mtimeMs: 0
+    }, spans),
+    tools: toolMeasurements(tools),
+    compactions: compactions(spans),
+    contextFootprints: contextFootprints(spans),
+    coverage: {
+      profile: "Native spans do not establish the authored or effective AgentProfile revision; join the Runtime profile receipt by recorded identity.",
+      materializedResources: "Captured attributes measure only the visible representation. Missing tools, skills, MCP definitions, and resources are unknown.",
+      contextTokens: "No tokenizer estimates are substituted for the actual request. Per-component context token counts require producer telemetry.",
+      toolTokens: "Tool byte counts are not model input tokens; token attribution to tool content is not captured.",
+      compaction: "Only recorded boundaries are counted. Zero-duration adapter defaults are not measured compaction latency.",
+      semanticAssessments: "Success at the task, useful skill application, waste, reward hacking, safety, and dishonesty require separately attributed evaluation."
+    }
+  };
+}
+
 // src/session-facts.ts
 import { OPENINFERENCE_SPAN_KIND as OPENINFERENCE_SPAN_KIND4, TOOL_NAME as TOOL_NAME5 } from "@tangle-network/agent-eval/trace-attributes";
 import { ingestSpans, rankFirstFailure } from "@tangle-network/agent-eval/diagnosis";
+var SESSION_FACTS_MEASUREMENT_VERSION = "3";
 var SESSION_TOKEN_TOTAL_ATTR = "traces.session.total_tokens";
 var SPAN_SYNTHESIZED_ATTR = "traces.codex.span_synthesized";
 var CORRUPTION_COUNT_ATTR = "traces.session.corruption_count";
@@ -8810,15 +9115,17 @@ function humanTurnsOf(spans) {
     excluded: [...excluded].sort(([left], [right]) => left.localeCompare(right)).map(([reason, spanIds]) => ({ reason, turns: spanIds.length, spanIds }))
   };
 }
-function computeSessionFacts(spans) {
+function computeSessionFacts(spans, options = {}) {
   const { sessionByTrace } = indexSessionIdsByTrace(spans);
   const byTrace = /* @__PURE__ */ new Map();
   for (const span2 of spans) {
-    byTrace.set(span2.trace_id, [...byTrace.get(span2.trace_id) ?? [], span2]);
+    const group = byTrace.get(span2.trace_id);
+    if (group) group.push(span2);
+    else byTrace.set(span2.trace_id, [span2]);
   }
-  return [...byTrace].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([traceId, traceSpans]) => sessionFactsForTrace(traceId, sessionByTrace.get(traceId) ?? null, traceSpans));
+  return [...byTrace].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([traceId, traceSpans]) => sessionFactsForTrace(traceId, sessionByTrace.get(traceId) ?? null, traceSpans, options));
 }
-function sessionFactsForTrace(traceId, sessionId, unordered) {
+function sessionFactsForTrace(traceId, sessionId, unordered, options) {
   const spans = [...unordered].sort(byTraceOrder);
   const harness = spans.map((span2) => stringAttr2(span2, "service.name")).find((name) => name !== null) ?? null;
   const ownSpans = spans.filter((span2) => !isSubagentSpan(span2.attributes));
@@ -8857,7 +9164,7 @@ function sessionFactsForTrace(traceId, sessionId, unordered) {
     (span2) => span2.parent_span_id !== null && span2.attributes[CORRUPTION_RECEIPT_VERSION_ATTR] === void 0
   ).length;
   const corruptionSpan = spans.find((span2) => typeof span2.attributes[CORRUPTION_COUNT_ATTR] === "number");
-  return {
+  const facts = {
     schemaVersion: 1,
     kind: "traces.session_facts",
     traceId,
@@ -8874,6 +9181,7 @@ function sessionFactsForTrace(traceId, sessionId, unordered) {
       spanIds: [],
       unavailable: `no span carries ${CORRUPTION_COUNT_ATTR}; this trace was not read through the session integrity path, so whether any record was skipped is unknown`
     },
+    measurements: computeSessionMeasurements(ownSpans, invoked, sessionId, harness),
     toolCalls: {
       value: invoked.length,
       spanIds: invoked.map((span2) => span2.span_id),
@@ -8926,15 +9234,50 @@ function sessionFactsForTrace(traceId, sessionId, unordered) {
       unavailable: `no span carries ${SESSION_TOKEN_TOTAL_ATTR}; the per-turn llm.turn deltas in this trace are a different quantity and summing them would not be the harness total`
     }
   };
+  if (options.includeContent !== false) return facts;
+  const withheld = () => ({
+    value: null,
+    spanIds: [],
+    unavailable: "Content was not requested."
+  });
+  return {
+    ...facts,
+    humanTurns: withheld(),
+    finalMessages: withheld(),
+    changedFiles: withheld(),
+    pullRequests: withheld(),
+    subagents: {
+      ...facts.subagents,
+      value: facts.subagents.value?.map((entry) => ({
+        ...entry,
+        taskName: null,
+        taskNameUnavailable: "Assignment text was not requested."
+      })) ?? null
+    },
+    firstFailure: facts.firstFailure.status === "found" ? { ...facts.firstFailure, message: null, classification: facts.firstFailure.classification ? { ...facts.firstFailure.classification, reason: "Content was not requested." } : null } : facts.firstFailure
+  };
 }
 function buildSessionFactsReport(spans, options = {}) {
+  const digest = createHash7("sha256");
+  const ordered2 = [...spans].sort((a, b) => a.trace_id.localeCompare(b.trace_id) || a.span_id.localeCompare(b.span_id));
+  let evidenceThrough = null;
+  for (const span2 of ordered2) {
+    digest.update(canonicalJson(span2)).update("\n");
+    for (const time of [span2.start_time, span2.end_time]) {
+      if (Number.isFinite(Date.parse(time)) && (evidenceThrough === null || Date.parse(time) > Date.parse(evidenceThrough))) evidenceThrough = time;
+    }
+  }
   return {
     schemaVersion: 1,
     kind: "traces.session_facts_report",
+    measurementVersion: SESSION_FACTS_MEASUREMENT_VERSION,
+    sourceDigest: "sha256:" + digest.digest("hex"),
+    evidenceThrough,
+    contentIncluded: options.includeContent !== false,
     generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
     harness: options.harness ?? null,
     spanCount: spans.length,
-    sessions: computeSessionFacts(spans)
+    sessions: computeSessionFacts(spans, options)
   };
 }
 function factLine(label2, fact, rendered) {
@@ -8983,6 +9326,8 @@ function renderSessionFacts(report) {
     lines.push(factLine("changed files", facts.changedFiles, String(facts.changedFiles.value?.length ?? 0)));
     lines.push(factLine("first record", facts.firstRecordAt, String(facts.firstRecordAt.value)));
     lines.push(factLine("last record", facts.lastRecordAt, String(facts.lastRecordAt.value)));
+    lines.push(factLine("compactions", facts.measurements.compactions, String(facts.measurements.compactions.value?.length ?? 0)));
+    lines.push("  skills: " + facts.measurements.adoption.totalSkillInvocations + " recorded invocation(s), " + facts.measurements.adoption.totalSkillDocumentReads + " document read(s); telemetry " + facts.measurements.adoption.skillTelemetryStatus);
     lines.push(factLine("token total", facts.tokenTotal, String(facts.tokenTotal.value)));
     lines.push(`  first failure: ${renderFirstFailure(facts.firstFailure)}`);
     if ((facts.unreadRecords.value ?? 0) > 0) {
@@ -9028,6 +9373,9 @@ ${JSON.stringify({ sessions, ...dropped2.length ? { omitted_fields: dropped2 } :
     ["tool_call_span_ids", (facts) => {
       facts.tool_calls.span_ids = [];
     }],
+    ["measurements", (facts) => {
+      delete facts.measurements;
+    }],
     ["tool_calls_by_name", (facts) => {
       delete facts.tool_calls_by_name;
     }],
@@ -9152,7 +9500,8 @@ function compactFacts(facts) {
     first_record_at: factJson(facts.firstRecordAt),
     last_record_at: factJson(facts.lastRecordAt),
     token_total: factJson(facts.tokenTotal),
-    first_failure: compactFirstFailure(facts.firstFailure)
+    first_failure: compactFirstFailure(facts.firstFailure),
+    measurements: facts.measurements
   };
 }
 function compactFirstFailure(failure2) {
@@ -9181,7 +9530,7 @@ function sessionFactsContext(spans, options = {}) {
   if (report.sessions.length === 0) return void 0;
   return renderSessionFactsContext(report, options);
 }
-var SESSION_FACTS_VERSION_SUFFIX = "session-facts.2";
+var SESSION_FACTS_VERSION_SUFFIX = "session-facts." + SESSION_FACTS_MEASUREMENT_VERSION;
 function withSessionFactsContext(definitions, spans, options = {}) {
   const sheet = sessionFactsContext(spans, options);
   if (sheet === void 0) return [...definitions];
@@ -9208,13 +9557,13 @@ import { OtlpFileTraceStore } from "@tangle-network/agent-eval/traces";
 
 // src/bundle-source.ts
 import { isUtf8 as isUtf82 } from "buffer";
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { constants } from "fs";
 import { lstat as lstat2, open, realpath as realpath3 } from "fs/promises";
 import { dirname as dirname8, isAbsolute as isAbsolute4, join as join20, relative as relative5, resolve as resolve7, sep as sep2 } from "path";
 
 // src/bundle.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import { copyFile, cp, lstat, mkdir as mkdir2, readdir as readdir16, readFile as readFile7, stat as stat14, writeFile as writeFile5 } from "fs/promises";
 import { dirname as dirname7, join as join19, relative as relative4, resolve as resolve6, sep } from "path";
 
@@ -10443,7 +10792,7 @@ function measured(value, render) {
 }
 function distributionRow(label2, distribution, unit = "") {
   if (distribution.n === 0) return `| ${label2} | 0 | not captured | not captured | not captured | not captured | not captured |`;
-  const value = (number) => measured(number, (captured) => `${decimal(captured)}${unit}`);
+  const value = (number2) => measured(number2, (captured) => `${decimal(captured)}${unit}`);
   return `| ${label2} | ${count(distribution.n)} | ${value(distribution.min)} | ${value(distribution.mean)} | ${value(distribution.p50)} | ${value(distribution.p95)} | ${value(distribution.max)} |`;
 }
 function tokenRows(usage) {
@@ -11794,7 +12143,7 @@ async function writeSessionIndexFile(index, outPath) {
 }
 
 // src/session-selection.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { createReadStream as createReadStream2 } from "fs";
 
 // src/session-workflow.ts
@@ -12120,7 +12469,7 @@ async function collectSessionWorkflow(adapter, seeds, options = {}) {
 // src/session-selection.ts
 async function fileSha256(path, signal) {
   signal?.throwIfAborted();
-  const hash2 = createHash7("sha256");
+  const hash2 = createHash8("sha256");
   try {
     for await (const chunk of createReadStream2(path, { signal })) {
       signal?.throwIfAborted();
@@ -12148,7 +12497,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 : createHash7("sha256").update(JSON.stringify(files)).digest("hex");
+  const sha2562 = files.length === 1 ? files[0].sha256 : createHash8("sha256").update(JSON.stringify(files)).digest("hex");
   return { sha256: sha2562, files };
 }
 function summarizeWorkflows(workflows) {
@@ -12274,8 +12623,8 @@ var KNOWN_LIMITS = [
   "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 createHash8("sha256").update(bytes).digest("hex");
+function sha256Hex(bytes2) {
+  return createHash9("sha256").update(bytes2).digest("hex");
 }
 function bundlePath(...parts) {
   return parts.join("/");
@@ -12682,13 +13031,13 @@ async function verifySessionBundle(bundleDir) {
   let source;
   if (manifest.projection) {
     const sourceManifest = join19(manifest.projection.sourceDirectory, "manifest.json");
-    const bytes = await readFile7(sourceManifest).catch((error) => {
+    const bytes2 = await readFile7(sourceManifest).catch((error) => {
       if (isMissingPathError(error)) return null;
       throw error;
     });
     source = {
       directory: manifest.projection.sourceDirectory,
-      status: bytes === null ? "unavailable" : sha256Hex(bytes) === manifest.projection.sourceManifestSha256 ? "match" : "mismatch"
+      status: bytes2 === null ? "unavailable" : sha256Hex(bytes2) === manifest.projection.sourceManifestSha256 ? "match" : "mismatch"
     };
   }
   return {
@@ -12732,8 +13081,8 @@ async function openBundleFile(root, file) {
   return handle;
 }
 async function fileDigest(handle, signal) {
-  const hash2 = createHash9("sha256");
-  for await (const bytes of handle.createReadStream({ start: 0, autoClose: false, signal })) hash2.update(bytes);
+  const hash2 = createHash10("sha256");
+  for await (const bytes2 of handle.createReadStream({ start: 0, autoClose: false, signal })) hash2.update(bytes2);
   return hash2.digest("hex");
 }
 async function validateFile(root, file, signal) {
@@ -12833,7 +13182,7 @@ async function createBundleSourceReader(directory, spans, options = {}) {
       handle = await openBundleFile(root, file);
       const before = await handle.stat();
       if (await fileDigest(handle, signal) !== file.sha256) return unavailable("retained source digest mismatch");
-      const hash2 = createHash9("sha256");
+      const hash2 = createHash10("sha256");
       const record2 = Buffer.alloc(ref.recordBytes);
       let position = 0;
       for await (const raw of handle.createReadStream({
@@ -12842,10 +13191,10 @@ async function createBundleSourceReader(directory, spans, options = {}) {
         autoClose: false,
         signal
       })) {
-        const bytes2 = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
-        hash2.update(bytes2);
-        bytes2.copy(record2, position);
-        position += bytes2.length;
+        const bytes3 = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+        hash2.update(bytes3);
+        bytes3.copy(record2, position);
+        position += bytes3.length;
       }
       const after = await handle.stat();
       if (position !== ref.recordBytes || hash2.digest("hex") !== ref.recordSha256 || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) {
@@ -12868,22 +13217,22 @@ async function createBundleSourceReader(directory, spans, options = {}) {
       if (input.offset > field.length) return unavailable("source offset is outside the selected field");
       const window = field.subarray(input.offset, Math.min(field.length, input.offset + input.limit));
       if (window.length > 0 && (window[0] & 192) === 128) return unavailable("offset splits a UTF-8 character");
-      let bytes = window;
+      let bytes2 = window;
       for (let omitted = 0; omitted <= 3; omitted += 1) {
-        bytes = window.subarray(0, Math.max(0, window.length - omitted));
-        if (isUtf82(bytes)) break;
+        bytes2 = window.subarray(0, Math.max(0, window.length - omitted));
+        if (isUtf82(bytes2)) break;
       }
-      if (!isUtf82(bytes) || bytes.length === 0 && input.offset < field.length) {
+      if (!isUtf82(bytes2) || bytes2.length === 0 && input.offset < field.length) {
         return unavailable("window cannot contain a complete UTF-8 character");
       }
-      const next = input.offset + bytes.length;
+      const next = input.offset + bytes2.length;
       return {
         status: "available",
         trace_id: input.trace_id,
         span_id: input.span_id,
         attribute: input.attribute,
         source_index: sourceIndex,
-        text: bytes.toString("utf8"),
+        text: bytes2.toString("utf8"),
         offset: input.offset,
         total_bytes: field.length,
         next_offset: next < field.length ? next : null,
@@ -13016,7 +13365,7 @@ async function analyzeSpans(spans, opts = {}) {
 }
 
 // src/chat-trajectory.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 function isChatTrajectoryMessage(value) {
   return isObject2(value) && typeof value.role === "string" && typeof value.content === "string";
 }
@@ -13101,7 +13450,7 @@ function trajectoryId(trajectory) {
   const value = trajectory.trajectory_id ?? trajectory.traj_id ?? trajectory.instance_id;
   if (typeof value === "string" && value.trim()) return value;
   if (typeof value === "number" && Number.isSafeInteger(value)) return String(value);
-  return `trajectory-${createHash10("sha256").update(JSON.stringify(trajectory.messages)).digest("hex").slice(0, 24)}`;
+  return `trajectory-${createHash11("sha256").update(JSON.stringify(trajectory.messages)).digest("hex").slice(0, 24)}`;
 }
 function messageKind(role) {
   const normalized = role.trim().toLowerCase();
@@ -13158,8 +13507,8 @@ function parseTime2(value) {
 }
 function finiteNumber(value, key) {
   if (!isObject2(value)) return void 0;
-  const number = value[key];
-  return typeof number === "number" && Number.isFinite(number) ? number : void 0;
+  const number2 = value[key];
+  return typeof number2 === "number" && Number.isFinite(number2) ? number2 : void 0;
 }
 function stringValue2(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
@@ -13178,10 +13527,10 @@ import {
   readFile as readFile10,
   rm as rm2
 } from "fs/promises";
-import { basename as basename14, dirname as dirname10, join as join23, resolve as resolve9 } from "path";
+import { basename as basename13, dirname as dirname10, join as join23, resolve as resolve9 } from "path";
 
 // src/codetracebench-files.ts
-import { createHash as createHash11, randomUUID } from "crypto";
+import { createHash as createHash12, randomUUID } from "crypto";
 import {
   link,
   lstat as lstat3,
@@ -13196,13 +13545,13 @@ import {
   writeFile as writeFile6
 } from "fs/promises";
 import { hostname } from "os";
-import { basename as basename13, dirname as dirname9, isAbsolute as isAbsolute5, join as join21, relative as relative6, resolve as resolve8, sep as sep3 } from "path";
+import { basename as basename12, dirname as dirname9, isAbsolute as isAbsolute5, join as join21, relative as relative6, resolve as resolve8, sep as sep3 } from "path";
 async function claimImportLock(input) {
   const claimId = randomUUID();
   const path = `${input.outputDirectory}.lock`;
   const temporary = join21(
     dirname9(path),
-    `.${basename13(path)}.${claimId}.tmp`
+    `.${basename12(path)}.${claimId}.tmp`
   );
   const metadata = {
     kind: "traces.codetracebench-import-lock",
@@ -13364,7 +13713,7 @@ async function atomicWriteFile(path, content, signal) {
   signal.throwIfAborted();
   const temporary = join21(
     dirname9(path),
-    `.${basename13(path)}.${randomUUID()}.tmp`
+    `.${basename12(path)}.${randomUUID()}.tmp`
   );
   try {
     await writeFile6(temporary, content, {
@@ -13379,7 +13728,7 @@ async function atomicWriteFile(path, content, signal) {
   }
 }
 function sha256(value) {
-  return createHash11("sha256").update(value).digest("hex");
+  return createHash12("sha256").update(value).digest("hex");
 }
 function isObject3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -13616,10 +13965,10 @@ async function readOptionalTask(trajectoryDirectory, caseDirectory, row, signal)
       content: `Task: ${row.taskName}`
     };
   }
-  const bytes = await readFile9(path, { signal });
-  const content = bytes.toString("utf8").trim();
+  const bytes2 = await readFile9(path, { signal });
+  const content = bytes2.toString("utf8").trim();
   if (!content) throw new Error(`${row.trajId}/task.md is empty`);
-  return { source: "task.md", content, path, bytes };
+  return { source: "task.md", content, path, bytes: bytes2 };
 }
 function assertNoLabelLeak(spans, row) {
   for (const item of spans) {
@@ -13697,7 +14046,7 @@ async function importCodeTraceBench(options) {
   const rowsPath = resolve9(options.rowsPath);
   const trajectoryPath = resolve9(options.trajectoryDir);
   const outputDirectory = resolve9(options.outDir);
-  const outputBase = basename14(outputDirectory);
+  const outputBase = basename13(outputDirectory);
   if (!outputBase || outputDirectory === dirname10(outputDirectory)) {
     throw new Error("CodeTraceBench output directory must not be a filesystem root");
   }
@@ -13801,10 +14150,10 @@ async function runCodeTraceBenchImport(input) {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       input: {
         revision,
-        rowsFile: basename14(rowsPath),
+        rowsFile: basename13(rowsPath),
         rowsSha256,
         rowsBytes: rowsBytes.byteLength,
-        trajectoryDirectory: basename14(trajectoryDirectory),
+        trajectoryDirectory: basename13(trajectoryDirectory),
         sha256: inputSha256
       },
       settings: {
@@ -14269,7 +14618,7 @@ async function cmdVerifyFindings(argv) {
 }
 
 // src/hodoscope.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { mkdir as mkdir5, mkdtemp as mkdtemp5, readFile as readFile11, readdir as readdir17, writeFile as writeFile7 } from "fs/promises";
 import { endianness, tmpdir as tmpdir5 } from "os";
 import { join as join24, resolve as resolve10 } from "path";
@@ -14308,7 +14657,7 @@ async function writeHodoscopeInput(otlpPath, options = {}) {
       throw new Error(`Hodoscope trace '${traceId}' contains no assistant actions`);
     }
     actionCount += actions;
-    const file = `${createHash12("sha256").update(traceId).digest("hex").slice(0, 24)}.json`;
+    const file = `${createHash13("sha256").update(traceId).digest("hex").slice(0, 24)}.json`;
     await writeFile7(join24(samples, file), `${JSON.stringify(trajectory, null, 2)}
 `, "utf8");
   }
@@ -14820,7 +15169,7 @@ function validateEmbedding(encoded, dimensions, path) {
       `Hodoscope ${path} encodes ${encoded.length} characters; expected ${expectedLength} for ${dimensions} float32 values`
     );
   }
-  const bytes = new Uint8Array(dimensions * 4);
+  const bytes2 = new Uint8Array(dimensions * 4);
   for (let group = 0; group < dimensions; group += 1) {
     let value = 0;
     const encodedOffset = group * 5;
@@ -14836,12 +15185,12 @@ function validateEmbedding(encoded, dimensions, path) {
       throw new Error(`Hodoscope ${path} contains an overflowing base85 block at index ${group}`);
     }
     const byteOffset = group * 4;
-    bytes[byteOffset] = Math.floor(value / 16777216) & 255;
-    bytes[byteOffset + 1] = Math.floor(value / 65536) & 255;
-    bytes[byteOffset + 2] = Math.floor(value / 256) & 255;
-    bytes[byteOffset + 3] = value & 255;
+    bytes2[byteOffset] = Math.floor(value / 16777216) & 255;
+    bytes2[byteOffset + 1] = Math.floor(value / 65536) & 255;
+    bytes2[byteOffset + 2] = Math.floor(value / 256) & 255;
+    bytes2[byteOffset + 3] = value & 255;
   }
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
   const littleEndian = endianness() === "LE";
   for (let index = 0; index < dimensions; index += 1) {
     if (!Number.isFinite(view.getFloat32(index * 4, littleEndian))) {
@@ -14956,7 +15305,7 @@ function assertPositiveInteger(name, value) {
 }
 
 // src/analyst-engine-prime.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 var DEFAULT_BRIDGE_URL = "http://localhost:4181";
@@ -14969,6 +15318,17 @@ 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";
+var TRAJECTORY_FILE_NAME = "trajectory.otlp.jsonl";
+async function fileDelivery(otlpPath, perAttributeCharCap, signal) {
+  signal?.throwIfAborted();
+  const { copyFile: copyFile2, mkdtemp: mkdtemp8, stat: stat19 } = await import("fs/promises");
+  const { tmpdir: tmpdir8 } = await import("os");
+  const { join: join35 } = await import("path");
+  const cwd = await mkdtemp8(join35(tmpdir8(), "traces-prime-"));
+  await copyFile2(otlpPath, join35(cwd, TRAJECTORY_FILE_NAME));
+  const artifactBytes = (await stat19(otlpPath)).size;
+  return { mode: "file-cwd", perAttributeCharCap, renderedChars: artifactBytes, cwd, fileName: TRAJECTORY_FILE_NAME };
+}
 function positiveIntegerEnv(name) {
   const raw = process.env[name];
   if (raw === void 0 || raw === "") return void 0;
@@ -15019,7 +15379,7 @@ function capRowAttributes(row, cap) {
   }
   return { ...row, attributes: capped };
 }
-async function projectArtifact(otlpPath, maxInlineChars, perAttributeCharCap, signal) {
+async function projectArtifact(otlpPath, maxInlineChars, perAttributeCharCap, deliveryMode, signal) {
   const rows = [];
   const spanTraces = /* @__PURE__ */ new Map();
   let index = 0;
@@ -15043,9 +15403,18 @@ async function projectArtifact(otlpPath, maxInlineChars, perAttributeCharCap, si
   }
   if (rows.length === 0) throw new Error(`${otlpPath} contains no spans`);
   const traceCount = new Set(rows.map((row) => row.trace_id)).size;
+  if (deliveryMode === "file") {
+    return {
+      rows,
+      rendered: null,
+      delivery: await fileDelivery(otlpPath, perAttributeCharCap, signal),
+      traceCount,
+      spanTraces
+    };
+  }
   let projected = rows;
   let rendered = JSON.stringify(projected);
-  const delivery = {
+  let delivery = {
     mode: "inline-json",
     perAttributeCharCap: null,
     renderedChars: rendered.length
@@ -15053,18 +15422,30 @@ async function projectArtifact(otlpPath, maxInlineChars, perAttributeCharCap, si
   if (rendered.length > maxInlineChars) {
     projected = rows.map((row) => capRowAttributes(row, perAttributeCharCap));
     rendered = JSON.stringify(projected);
-    delivery.perAttributeCharCap = perAttributeCharCap;
-    delivery.renderedChars = rendered.length;
+    delivery = {
+      mode: "inline-json",
+      perAttributeCharCap,
+      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`
-    );
+    if (deliveryMode === "inline") {
+      throw new Error(
+        `trajectory renders to ${rendered.length} chars even at per-attribute cap ${perAttributeCharCap} (budget ${maxInlineChars}); inline delivery impossible`
+      );
+    }
+    return {
+      rows,
+      rendered: null,
+      delivery: await fileDelivery(otlpPath, perAttributeCharCap, signal),
+      traceCount,
+      spanTraces
+    };
   }
   return { rows: projected, rendered, delivery, traceCount, spanTraces };
 }
 var OUTPUT_CONTRACT_LINES = [
-  "OUTPUT CONTRACT (you have no trace tools and no REPL):",
+  "OUTPUT CONTRACT (inline delivery \u2014 the whole trajectory is in this prompt):",
   "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:",
@@ -15080,7 +15461,35 @@ var OUTPUT_CONTRACT_LINES = [
   `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.'
 ];
+var FILE_DELIVERY_CONTRACT_LINES = [
+  "OUTPUT CONTRACT (file delivery \u2014 the trajectory is a FILE in your working directory):",
+  `You are a recursive language model with a REPL. The trajectory is ${TRAJECTORY_FILE_NAME} in your`,
+  "working directory: OpenInference JSONL, one span object per line. Load it yourself and inspect it with code",
+  '(e.g. rows = [json.loads(line) for line in open("trajectory.otlp.jsonl")]), paging rather than printing it whole;',
+  "fan out with rlm() for sub-questions when that pays for itself. Stay inside your working directory.",
+  "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 ${TRAJECTORY_FILE_NAME}.`,
+  '"findings" is [] only for a clean trajectory.'
+];
 function buildPrompt(question, projection) {
+  if (projection.delivery.mode === "file-cwd") {
+    return [
+      `QUESTION: ${question}`,
+      "",
+      ...FILE_DELIVERY_CONTRACT_LINES,
+      "",
+      `TRAJECTORY (${projection.traceCount} trace(s); ${projection.rows.length} spans): the file ${projection.delivery.fileName} in your working directory (${projection.delivery.renderedChars} bytes). It is NOT inlined in this prompt.`
+    ].join("\n");
+  }
   return [
     `QUESTION: ${question}`,
     "",
@@ -15180,7 +15589,7 @@ function toAnalystFinding(row, index, spanTraces, model, producedAt) {
     const traces = spanTraces.get(spanId);
     return spanEvidenceUri([...traces][0], spanId);
   });
-  const findingId = `prime-${createHash13("sha256").update(`${index}
+  const findingId = `prime-${createHash14("sha256").update(`${index}
 ${row.claim}
 ${uris.join("\n")}`).digest("hex").slice(0, 12)}`;
   return {
@@ -15227,7 +15636,7 @@ var httpJsonTransport = ({ url, body, signal }) => {
 };
 var PrimeBridgeError = class extends Error {
 };
-async function callBridge(transport, url, model, content, timeoutMs, callerSignal, turn) {
+async function callBridge(transport, url, model, content, timeoutMs, callerSignal, turn, cwd) {
   const controller = new AbortController();
   const timer = setTimeout(
     () => controller.abort(new Error(`${turn}bridge call exceeded ${timeoutMs}ms`)),
@@ -15240,7 +15649,7 @@ async function callBridge(transport, url, model, content, timeoutMs, callerSigna
   try {
     response = await transport({
       url,
-      body: { model, messages: [{ role: "user", content }] },
+      body: { model, messages: [{ role: "user", content }], ...cwd ? { cwd } : {} },
       signal: controller.signal
     });
   } catch (error) {
@@ -15287,6 +15696,10 @@ function primeAnalyzer(opts = {}) {
     throw new RangeError("perAttributeCharCap must be a positive safe integer");
   }
   const repairEnabled = opts.repair ?? true;
+  const deliveryMode = opts.delivery ?? "auto";
+  if (deliveryMode !== "auto" && deliveryMode !== "file" && deliveryMode !== "inline") {
+    throw new RangeError(`delivery must be 'auto', 'file', or 'inline', got '${String(deliveryMode)}'`);
+  }
   const transport = opts.transport ?? httpJsonTransport;
   const url = `${bridgeUrl}/v1/chat/completions`;
   return {
@@ -15294,12 +15707,19 @@ function primeAnalyzer(opts = {}) {
     async analyze(otlpPath, analyzeOpts = {}) {
       let projection;
       try {
-        projection = await projectArtifact(otlpPath, maxInlineChars, perAttributeCharCap, analyzeOpts.signal);
+        projection = await projectArtifact(
+          otlpPath,
+          maxInlineChars,
+          perAttributeCharCap,
+          deliveryMode,
+          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"})`;
+      const deliveryLine = projection.delivery.mode === "file-cwd" ? `delivery: file-cwd (${projection.rows.length} spans; ${projection.delivery.fileName} in cwd ${projection.delivery.cwd}, ${projection.delivery.renderedChars} bytes; per-attribute cap not applied)` : `delivery: ${projection.delivery.mode} (${projection.delivery.renderedChars} chars, per-attribute cap ${projection.delivery.perAttributeCharCap ?? "none"})`;
+      const deliveryCwd = projection.delivery.mode === "file-cwd" ? projection.delivery.cwd : void 0;
       let reply;
       try {
         reply = await callBridge(
@@ -15309,7 +15729,8 @@ function primeAnalyzer(opts = {}) {
           buildPrompt(question, projection),
           timeoutMs,
           analyzeOpts.signal,
-          ""
+          "",
+          deliveryCwd
         );
       } catch (error) {
         if (!(error instanceof PrimeBridgeError)) throw error;
@@ -15466,7 +15887,7 @@ async function applyRedactor(spans, redactor) {
 }
 
 // src/file-export.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { mkdtemp as mkdtemp6, readFile as readFile12, writeFile as writeFile8 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
 import { join as join25 } from "path";
@@ -15504,7 +15925,7 @@ function stableJson(value) {
   });
 }
 function hashId(value, chars = 16) {
-  return createHash14("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
+  return createHash15("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
 }
 function isoTime2(value) {
   if (typeof value === "string") {
@@ -16148,7 +16569,7 @@ async function writeTraceEvidenceExportFile(inputPath, outPath, opts = {}) {
 // src/inspect.ts
 import { mkdtemp as mkdtemp7, readFile as readFile13, writeFile as writeFile9 } from "fs/promises";
 import { tmpdir as tmpdir7 } from "os";
-import { basename as basename15, join as join26 } from "path";
+import { basename as basename14, join as join26 } from "path";
 var severityRank2 = {
   high: 0,
   medium: 1,
@@ -16331,7 +16752,7 @@ function addContextFindings(index, findings) {
       refs: invalidJsonlFiles.slice(0, 5).map((file) => file.path)
     });
   }
-  const skillRunFiles = files.filter((file) => basename15(file.path) === "skill-runs.jsonl" && (file.jsonl?.rows ?? 0) > 0).map((file) => {
+  const skillRunFiles = files.filter((file) => basename14(file.path) === "skill-runs.jsonl" && (file.jsonl?.rows ?? 0) > 0).map((file) => {
     const rows = file.jsonl?.rows ?? 0;
     const keys = file.jsonl?.keys ?? {};
     const linkKeyCounts = {
@@ -16443,7 +16864,7 @@ async function writeInspectionReportFile(report, outPath) {
 }
 
 // src/live.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } 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;
@@ -16463,7 +16884,7 @@ var sleep = (ms2, signal) => new Promise((resolve13) => {
   signal?.addEventListener("abort", onAbort, { once: true });
 });
 function hash(parts) {
-  return createHash15("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
+  return createHash16("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
 }
 function asString(value) {
   if (typeof value === "string" && value.trim()) return value;
@@ -16871,7 +17292,7 @@ async function streamSessions(opts) {
 
 // src/supervisor-run-context.ts
 import { readFile as readFile14, stat as stat16 } from "fs/promises";
-import { basename as basename16, join as join27 } from "path";
+import { basename as basename15, join as join27 } from "path";
 import { materializeTreeView } from "@tangle-network/agent-runtime/kernel";
 import {
   readRuntimeSupervisorRun
@@ -17037,7 +17458,7 @@ async function readFileRunContext(runDir, opts = {}) {
   return {
     ...sources,
     instanceId: opts.instanceId !== void 0 ? opts.instanceId : sources.instanceId,
-    arm: opts.arm !== void 0 ? opts.arm : basename16(runDir),
+    arm: opts.arm !== void 0 ? opts.arm : basename15(runDir),
     workers: sources.workers !== null && coordination.present ? workerSources(sources.workers, coordination) : sources.workers,
     ...sources.journal !== null ? {
       rootTranscriptRef: join27(runDir, SPAWN_JOURNAL_FILE),
@@ -18689,7 +19110,7 @@ async function watchSessions(opts) {
 }
 
 // src/bundle-view.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import { mkdir as mkdir7, readdir as readdir20, readFile as readFile16, writeFile as writeFile11 } from "fs/promises";
 import { dirname as dirname11, join as join31, resolve as resolve12 } from "path";
 var EVIDENCE_ONLY_ALLOW_LIST = [
@@ -18882,8 +19303,8 @@ async function projectSessionBundle(opts) {
   const candidates = [];
   for (const path of await listSessionBundleFiles(sourceDir)) {
     if (path === "manifest.json") continue;
-    const bytes = await readFile16(join31(sourceDir, path));
-    const sha2562 = createHash16("sha256").update(bytes).digest("hex");
+    const bytes2 = await readFile16(join31(sourceDir, path));
+    const sha2562 = createHash17("sha256").update(bytes2).digest("hex");
     const recorded = sourceHashes.get(path);
     if (!recorded) {
       throw new Error(
@@ -18897,10 +19318,10 @@ async function projectSessionBundle(opts) {
     }
     const verdict = classifyEvidenceOnlyPath(path);
     if (!verdict.carried) {
-      excluded.push({ path, bytes: bytes.length, sha256: sha2562, rule: verdict.rule, reason: verdict.reason });
+      excluded.push({ path, bytes: bytes2.length, sha256: sha2562, rule: verdict.rule, reason: verdict.reason });
       continue;
     }
-    candidates.push({ path, bytes, sha256: sha2562, carries: verdict.carries, owned: verdict.owned });
+    candidates.push({ path, bytes: bytes2, sha256: sha2562, carries: verdict.carries, owned: verdict.owned });
   }
   const report = await findSessionTextLeaks({
     viewDir: sourceDir,
@@ -18959,7 +19380,7 @@ async function projectSessionBundle(opts) {
     knownLimits: [...source.knownLimits, ...EVIDENCE_ONLY_LIMITS],
     projection: {
       sourceDirectory: sourceDir,
-      sourceManifestSha256: createHash16("sha256").update(sourceManifestBytes).digest("hex"),
+      sourceManifestSha256: createHash17("sha256").update(sourceManifestBytes).digest("hex"),
       leakCheck
     }
   };
@@ -19169,7 +19590,7 @@ function alreadyUploaded(state, harness, sessionId, hash2) {
 import { readFile as readFile18 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
 import { hostname as hostname2 } from "os";
-import { basename as basename17, join as join33 } from "path";
+import { basename as basename16, join as join33 } from "path";
 import { hostedClientFromEnv } from "@tangle-network/agent-eval/hosted";
 import { assessShareSafety as assessShareSafety2, REDACTION_VERSION, redact as redact2, shareAllowed } from "@tangle-network/agent-eval/traces";
 var require2 = createRequire2(import.meta.url);
@@ -19203,7 +19624,7 @@ async function gitBranch(cwd) {
 async function sessionMeta(item) {
   const meta = {
     [ATTR.HARNESS]: item.ref.harness,
-    [ATTR.SESSION_FILE]: basename17(item.ref.path),
+    [ATTR.SESSION_FILE]: basename16(item.ref.path),
     [ATTR.HOST]: hostname2(),
     [ATTR.UPLOADER]: `tangle-traces@${TRACES_VERSION}`,
     [ATTR.REDACTION_VERSION]: REDACTION_VERSION,
@@ -19369,7 +19790,7 @@ async function executeUpload(plan, opts = {}) {
 
 // src/verify-safe.ts
 import { lstat as lstat4, readdir as readdir21, readFile as readFile19 } from "fs/promises";
-import { basename as basename18, extname, join as join34, relative as relative7 } from "path";
+import { basename as basename17, extname, join as join34, relative as relative7 } from "path";
 import {
   assessShareSafety as assessShareSafety3,
   combineVerdicts as combineVerdicts2
@@ -19382,15 +19803,15 @@ async function verifySafe(target, options = {}) {
   const unreadable = [];
   const files = await listFiles(target, unreadable);
   for (const file of files) {
-    const label2 = relative7(target, file) || basename18(file);
-    let bytes;
+    const label2 = relative7(target, file) || basename17(file);
+    let bytes2;
     try {
-      bytes = await readFile19(file);
+      bytes2 = await readFile19(file);
     } catch (error) {
       unreadable.push(`${label2}: ${error instanceof Error ? error.message : String(error)}`);
       continue;
     }
-    const text2 = decodeUtf8(bytes);
+    const text2 = decodeUtf8(bytes2);
     if (text2 === void 0) {
       unreadable.push(`${label2}: not UTF-8 text`);
       continue;
@@ -19439,10 +19860,10 @@ async function listFiles(target, unreadable) {
   await walk(target);
   return out;
 }
-function decodeUtf8(bytes) {
-  if (bytes.includes(0)) return void 0;
+function decodeUtf8(bytes2) {
+  if (bytes2.includes(0)) return void 0;
   try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes2);
   } catch {
     return void 0;
   }
@@ -19513,6 +19934,7 @@ export {
   EXPORT_RULE,
   toOpenInferenceSpan,
   serializeSpans,
+  iterSerializedSpans,
   writeOtlpFile,
   summarizeOtlpExecution,
   summarizeSpanExecution,
@@ -19574,6 +19996,7 @@ export {
   serializePolicyEvidence,
   writePolicyEvidenceFile,
   countSkillRunsJsonl,
+  computeAdoption,
   analyzeAdoption,
   planTraceAgenticRoute,
   traceAgenticKinds,
@@ -19585,6 +20008,7 @@ export {
   shellCommands,
   commandTextFromInput,
   readPullRequests,
+  SESSION_FACTS_MEASUREMENT_VERSION,
   SESSION_TOKEN_TOTAL_ATTR,
   SPAN_SYNTHESIZED_ATTR,
   FACT_TEXT_CAP,