@tangle-network/traces 0.16.4 → 0.17.0

package/dist/{chunk-SMT635QV.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();
@@ -2229,6 +2249,7 @@ function createClaudeStream(startStep) {
     step: startStep,
     sawUserTurn: false,
     promptSpans: [],
+    promptSpanByUid: /* @__PURE__ */ new Map(),
     sawRecordedOrigin: false,
     firstRecordAt: null,
     lastRecordAt: null
@@ -2261,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)) {
@@ -2402,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) {
@@ -2416,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;
 }
@@ -2440,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);
@@ -2553,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) {
@@ -2582,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({
@@ -2743,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);
 }
@@ -2895,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") {
@@ -4301,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`,
@@ -4321,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 } : {}
@@ -4495,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}`;
@@ -6158,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}`;
@@ -7395,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(
@@ -7452,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);
@@ -7500,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 {
@@ -8458,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],
@@ -8503,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 };
   }
@@ -8592,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";
@@ -8869,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));
@@ -8916,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,
@@ -8933,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),
@@ -8985,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) {
@@ -9042,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) {
@@ -9087,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;
     }],
@@ -9211,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) {
@@ -9240,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];
@@ -9267,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";
 
@@ -10502,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) {
@@ -11853,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
@@ -12179,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();
@@ -12207,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) {
@@ -12333,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("/");
@@ -12741,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 {
@@ -12791,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) {
@@ -12892,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({
@@ -12901,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) {
@@ -12927,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,
@@ -13075,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";
 }
@@ -13160,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();
@@ -13217,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;
@@ -13240,7 +13530,7 @@ import {
 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,
@@ -13438,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);
@@ -13675,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) {
@@ -14328,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";
@@ -14367,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");
   }
@@ -14879,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;
@@ -14895,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))) {
@@ -15015,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";
@@ -15028,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;
@@ -15078,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;
@@ -15102,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
@@ -15112,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:",
@@ -15139,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}`,
     "",
@@ -15239,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 {
@@ -15286,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`)),
@@ -15299,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) {
@@ -15346,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 {
@@ -15353,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(
@@ -15368,7 +15729,8 @@ function primeAnalyzer(opts = {}) {
           buildPrompt(question, projection),
           timeoutMs,
           analyzeOpts.signal,
-          ""
+          "",
+          deliveryCwd
         );
       } catch (error) {
         if (!(error instanceof PrimeBridgeError)) throw error;
@@ -15525,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";
@@ -15563,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") {
@@ -16502,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;
@@ -16522,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;
@@ -18748,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 = [
@@ -18941,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(
@@ -18956,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,
@@ -19018,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
     }
   };
@@ -19442,14 +19804,14 @@ async function verifySafe(target, options = {}) {
   const files = await listFiles(target, unreadable);
   for (const file of files) {
     const label2 = relative7(target, file) || basename17(file);
-    let bytes;
+    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;
@@ -19498,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;
   }
@@ -19572,6 +19934,7 @@ export {
   EXPORT_RULE,
   toOpenInferenceSpan,
   serializeSpans,
+  iterSerializedSpans,
   writeOtlpFile,
   summarizeOtlpExecution,
   summarizeSpanExecution,
@@ -19633,6 +19996,7 @@ export {
   serializePolicyEvidence,
   writePolicyEvidenceFile,
   countSkillRunsJsonl,
+  computeAdoption,
   analyzeAdoption,
   planTraceAgenticRoute,
   traceAgenticKinds,
@@ -19644,6 +20008,7 @@ export {
   shellCommands,
   commandTextFromInput,
   readPullRequests,
+  SESSION_FACTS_MEASUREMENT_VERSION,
   SESSION_TOKEN_TOTAL_ATTR,
   SPAN_SYNTHESIZED_ATTR,
   FACT_TEXT_CAP,