@tangle-network/traces 0.8.26 → 0.9.0

package/dist/{chunk-6N2KVDOU.js → chunk-5SBXL62V.js}

@@ -1,6 +1,214 @@
+// src/attributes.ts
+var ATTR = {
+  /** = the trace/session id. Wire contract (dedup linkage). */
+  SESSION_ID: "tangle.sessionId",
+  /** "cli" marks a CLI upload so the platform can drop a re-upload of a session
+   *  that also streamed live. Wire contract. */
+  INGEST_SOURCE: "tangle.ingest_source",
+  HARNESS: "tangle.harness",
+  CWD: "tangle.cwd",
+  /** THE per-session grouping key the spine derives subjects from
+   *  (`deriveSubjectKey` reads `tangle.subject.key` first). Resolves to the git
+   *  remote (host/owner/repo) when readable, else the cwd path basename. */
+  SUBJECT_KEY: "tangle.subject.key",
+  /** Normalized git remote (e.g. `github.com/tangle-network/agent-dev-container`). */
+  GIT_REPOSITORY: "git.repository",
+  /** Current branch at conversion time. */
+  GIT_BRANCH_NAME: "git.branch",
+  /** HEAD short sha at conversion time. */
+  GIT_COMMIT: "git.commit",
+  /** How traces resolved the session cwd: recorded cwd, repaired cwd, or span path. */
+  REPO_RESOLUTION_SOURCE: "traces.repo_resolution_source",
+  GIT_BRANCH: "tangle.git_branch",
+  HOST: "tangle.host",
+  /** Basename of the session file. (Renamed from the ambiguous `tangle.source`,
+   *  which collided with `tangle.ingest_source`.) */
+  SESSION_FILE: "tangle.session_file",
+  UPLOADED_AT: "tangle.uploaded_at",
+  UPLOADER: "tangle.uploader",
+  REDACTION_VERSION: "redaction.version",
+  REDACTION_COUNT: "redaction.count",
+  /** Upload contract: bounded root summary plus location-only receipt child spans.
+   *  Receipt hashes are deliberate integrity evidence; raw malformed bytes never upload. */
+  SESSION_INTEGRITY: "traces.session.integrity",
+  CORRUPTION_COUNT: "traces.session.corruption_count",
+  CORRUPTION_DIGEST: "traces.session.corruption_digest",
+  CORRUPTION_RECEIPT_VERSION: "traces.session.corruption.receipt_version",
+  CORRUPTION_RECEIPT_KIND: "traces.session.corruption.kind",
+  CORRUPTION_SOURCE_PATH: "traces.session.corruption.source_path",
+  CORRUPTION_LINE_NUMBER: "traces.session.corruption.line_number",
+  CORRUPTION_BYTE_OFFSET: "traces.session.corruption.byte_offset",
+  CORRUPTION_BYTE_LENGTH: "traces.session.corruption.byte_length",
+  CORRUPTION_SHA256: "traces.session.corruption.sha256",
+  RAW_SOURCE_RETENTION: "traces.session.raw_source_retention"
+};
+var INGEST_SOURCE_CLI = "cli";
+var DEFAULT_HARNESS = "claude-code";
+var SESSION_ID_ATTRIBUTE_KEYS = [ATTR.SESSION_ID, "session.id", "traces.session.id"];
+function sessionIdFromAttributes(attributes) {
+  return SESSION_ID_ATTRIBUTE_KEYS.map((key) => attributes[key]).find(
+    (value) => typeof value === "string" && value.length > 0
+  );
+}
+function indexSessionIdsByTrace(spans) {
+  const candidatesByTrace = /* @__PURE__ */ new Map();
+  for (const span2 of spans) {
+    const candidates = candidatesByTrace.get(span2.trace_id) ?? /* @__PURE__ */ new Set();
+    for (const key of SESSION_ID_ATTRIBUTE_KEYS) {
+      const value = span2.attributes[key];
+      if (typeof value === "string" && value.length > 0) candidates.add(value);
+    }
+    if (candidates.size > 0) candidatesByTrace.set(span2.trace_id, candidates);
+  }
+  const sessionByTrace = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  for (const [traceId, candidates] of candidatesByTrace) {
+    const sessionIds2 = [...candidates].sort();
+    if (sessionIds2.length === 1) {
+      sessionByTrace.set(traceId, sessionIds2[0]);
+    } else {
+      conflicts.push({ traceId, sessionIds: sessionIds2 });
+    }
+  }
+  conflicts.sort((a, b) => a.traceId.localeCompare(b.traceId));
+  return { sessionByTrace, conflicts };
+}
+function stampSessionIdentity(spans, fallbackSessionId) {
+  const { sessionByTrace, conflicts } = indexSessionIdsByTrace(spans);
+  const conflictingTraceIds = new Set(conflicts.map((conflict) => conflict.traceId));
+  const traceIds = new Set(spans.map((span2) => span2.trace_id));
+  const singleTraceId = traceIds.size === 1 ? traceIds.values().next().value : void 0;
+  for (const span2 of spans) {
+    if (conflictingTraceIds.has(span2.trace_id)) continue;
+    const sessionId = sessionByTrace.get(span2.trace_id) ?? singleTraceId ?? fallbackSessionId;
+    if (!sessionIdFromAttributes(span2.attributes)) {
+      span2.attributes[ATTR.SESSION_ID] = sessionId;
+    }
+  }
+}
+
 // src/adoption.ts
 import { readFile } from "fs/promises";
 import { join } from "path";
+
+// src/adapters/tool-io.ts
+import { createHash } from "crypto";
+var TOOL_IO_VALUE_MAX_BYTES = 16 * 1024;
+var TOOL_IO_VALUE_KEYS = ["input.value", "output.value"];
+var TOOL_IO_SIDES = ["input", "output"];
+var LEGACY_TRUNCATION_MARKER = /\n\[truncated (\d+) bytes; sha256=[a-f0-9]{64}\]$/;
+var COUNTED_TRUNCATION_MARKER = /\n\[truncated \d+ bytes\]$/;
+var TRUNCATION_MARKER = /\n\[truncated\]$/;
+function canonicalJson(value) {
+  const sort = (item) => {
+    if (Array.isArray(item)) return item.map(sort);
+    if (!item || typeof item !== "object") return item;
+    return Object.fromEntries(
+      Object.entries(item).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => [key, sort(entry)])
+    );
+  };
+  const json2 = JSON.stringify(sort(value));
+  if (json2 === void 0) throw new TypeError("tool I/O value is not JSON-serializable");
+  return json2;
+}
+function serialize(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        return { value: canonicalJson(JSON.parse(trimmed)), mimeType: "application/json" };
+      } catch {
+      }
+    }
+    return { value, mimeType: "text/plain" };
+  }
+  return { value: canonicalJson(value), mimeType: "application/json" };
+}
+function utf8Prefix(value, maxBytes) {
+  let bytes = 0;
+  let end = 0;
+  for (const char of value) {
+    const charBytes = Buffer.byteLength(char);
+    if (bytes + charBytes > maxBytes) break;
+    bytes += charBytes;
+    end += char.length;
+  }
+  return Buffer.from(value.slice(0, end), "utf8").toString("utf8");
+}
+function truncatedValue(value, bytes) {
+  const longestMarker = `
+[truncated ${bytes} bytes]`;
+  const prefix = utf8Prefix(value, TOOL_IO_VALUE_MAX_BYTES - Buffer.byteLength(longestMarker));
+  const omittedBytes = bytes - 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 sha256 = createHash("sha256").update(serialized.value).digest("hex");
+  const truncated = bytes > TOOL_IO_VALUE_MAX_BYTES;
+  const value = truncated ? truncatedValue(serialized.value, bytes) : serialized.value;
+  return {
+    [`${side}.value`]: value,
+    [`${side}.mime_type`]: serialized.mimeType,
+    [`traces.${side}.bytes`]: bytes,
+    [`traces.${side}.sha256`]: sha256,
+    [`traces.${side}.truncated`]: truncated
+  };
+}
+function toolIoAttributes(io) {
+  return {
+    ...valueAttributes("input", io.input),
+    ...valueAttributes("output", io.output),
+    ...io.argsCaptured === void 0 ? {} : { "tool.args_captured": io.argsCaptured }
+  };
+}
+function toolArgumentsFromAttributes(attributes) {
+  const declared = attributes["tool.args_captured"];
+  const explicit = typeof declared === "boolean" ? declared : declared === "true" ? true : declared === "false" ? false : void 0;
+  const argsCaptured = explicit ?? attributes["input.value"] !== void 0;
+  return {
+    args: argsCaptured ? attributes["input.value"] : void 0,
+    argsCaptured
+  };
+}
+function normalizeToolIoAttributes(attributes) {
+  for (const side of TOOL_IO_SIDES) {
+    const valueKey = `${side}.value`;
+    const mimeKey = `${side}.mime_type`;
+    const bytesKey = `traces.${side}.bytes`;
+    const digestKey = `traces.${side}.sha256`;
+    const truncatedKey = `traces.${side}.truncated`;
+    const rawValue = attributes[valueKey];
+    if (typeof rawValue !== "string") {
+      delete attributes[mimeKey];
+      delete attributes[bytesKey];
+      delete attributes[digestKey];
+      delete attributes[truncatedKey];
+      continue;
+    }
+    let value = rawValue.replace(LEGACY_TRUNCATION_MARKER, "\n[truncated]").replace(COUNTED_TRUNCATION_MARKER, "\n[truncated]");
+    let truncated = TRUNCATION_MARKER.test(value);
+    const unboundedBytes = Buffer.byteLength(value);
+    if (unboundedBytes > TOOL_IO_VALUE_MAX_BYTES) {
+      value = truncatedValue(value, unboundedBytes);
+      truncated = true;
+    }
+    attributes[valueKey] = value;
+    attributes[bytesKey] = Buffer.byteLength(value);
+    attributes[digestKey] = createHash("sha256").update(value).digest("hex");
+    attributes[truncatedKey] = truncated;
+  }
+}
+function recordToolOutput(toolSpan, output) {
+  if (!toolSpan) return;
+  Object.assign(toolSpan.attributes, valueAttributes("output", output));
+}
+
+// src/adoption.ts
 function toolName(s) {
   const n = s.attributes["tool.name"];
   if (typeof n === "string") return n;
@@ -8,10 +216,14 @@ function toolName(s) {
   return null;
 }
 function parseInput(s) {
-  const c = s.attributes.content;
-  if (typeof c !== "string") return {};
+  const captured = toolArgumentsFromAttributes(s.attributes);
+  if (!captured.argsCaptured) return {};
+  if (captured.args && typeof captured.args === "object") {
+    return captured.args;
+  }
+  if (typeof captured.args !== "string") return {};
   try {
-    const v = JSON.parse(c);
+    const v = JSON.parse(captured.args);
     return v && typeof v === "object" ? v : {};
   } catch {
     return {};
@@ -22,9 +234,34 @@ function skillNameOf(input) {
   return typeof v === "string" && v.length > 0 ? v : "?";
 }
 function subagentTypeOf(input) {
-  const v = input.subagent_type;
+  const v = input.subagent_type ?? input.agent_type ?? input.type ?? input.name;
   return typeof v === "string" && v.length > 0 ? v : "?";
 }
+function isSpawnAgentTool(name) {
+  return name === "spawn_agent" || name.endsWith("__spawn_agent");
+}
+function skillTelemetryCapability(service) {
+  if (service === "claude-code") return "supported";
+  if (service === "codex") return "unsupported";
+  return "unknown";
+}
+var MATERIALIZED_SKILL_RE = /<skills_instructions>|(?:^|\n)#{1,3}\s+(?:available\s+)?skills\b|base directory for this skill:/i;
+function hasMaterializedSkillEvidence(s) {
+  if (s.name !== "message.developer" && s.attributes["tangle.actor"] !== "injected") return false;
+  const content = s.attributes.content;
+  return typeof content === "string" && MATERIALIZED_SKILL_RE.test(content);
+}
+function hasSkillFileReference(s) {
+  if (s.attributes["openinference.span.kind"] !== "TOOL") return false;
+  const input = s.attributes["input.value"];
+  return typeof input === "string" && input.includes("SKILL.md");
+}
+function telemetryStatus(measured, unsupported, unknown) {
+  if (measured > 0 && unsupported === 0 && unknown === 0) return "measured";
+  if (measured > 0) return "partial";
+  if (unsupported > 0 && unknown === 0) return "unsupported";
+  return "unknown";
+}
 function countSkillRunsJsonl(raw) {
   const out = {};
   for (const line of raw.split("\n")) {
@@ -68,32 +305,84 @@ async function readLoopRuns(cwds) {
   return { counts, filesRead };
 }
 async function analyzeAdoption(spans, opts = {}) {
+  const { sessionByTrace, conflicts } = indexSessionIdsByTrace(spans);
+  const identifiedSessions = new Set(sessionByTrace.values());
+  const unassignedTraceIds = new Set(
+    spans.map((span2) => span2.trace_id).filter((traceId) => !sessionByTrace.has(traceId))
+  );
+  const executionGroup = (span2) => sessionByTrace.get(span2.trace_id) ?? `trace:${span2.trace_id}`;
   const sessions = /* @__PURE__ */ new Set();
   const sessionsWithSkill = /* @__PURE__ */ new Set();
   const sessionsWithSubagent = /* @__PURE__ */ new Set();
+  const sessionsWithMaterializedSkills = /* @__PURE__ */ new Set();
+  const sessionsWithSkillFileReference = /* @__PURE__ */ new Set();
   const skillInvocations = {};
   const subagentSpawns = {};
+  const canonicalSubagentSessions = /* @__PURE__ */ new Set();
+  const fallbackSubagents = /* @__PURE__ */ new Map();
+  const sessionCapabilities = /* @__PURE__ */ new Map();
   for (const s of spans) {
-    sessions.add(s.trace_id);
+    const group = executionGroup(s);
+    sessions.add(group);
+    const observedCapability = skillTelemetryCapability(s.attributes["service.name"]);
+    const currentCapability = sessionCapabilities.get(group) ?? "unknown";
+    if (observedCapability === "supported" || currentCapability === "unknown") {
+      sessionCapabilities.set(group, observedCapability);
+    }
+    if (hasMaterializedSkillEvidence(s)) sessionsWithMaterializedSkills.add(group);
+    if (hasSkillFileReference(s)) sessionsWithSkillFileReference.add(group);
     const tn = toolName(s);
     if (tn === "Skill") {
+      sessionCapabilities.set(group, "supported");
       const name = skillNameOf(parseInput(s));
       skillInvocations[name] = (skillInvocations[name] ?? 0) + 1;
-      sessionsWithSkill.add(s.trace_id);
+      sessionsWithSkill.add(group);
     } else if (tn === "Task" || tn === "Agent") {
       const type = subagentTypeOf(parseInput(s));
       subagentSpawns[type] = (subagentSpawns[type] ?? 0) + 1;
-      sessionsWithSubagent.add(s.trace_id);
+      sessionsWithSubagent.add(group);
+      canonicalSubagentSessions.add(group);
+    } else if (tn && isSpawnAgentTool(tn)) {
+      const types = fallbackSubagents.get(group) ?? [];
+      types.push(subagentTypeOf(parseInput(s)));
+      fallbackSubagents.set(group, types);
+    }
+  }
+  for (const [traceId, types] of fallbackSubagents) {
+    if (canonicalSubagentSessions.has(traceId)) continue;
+    sessionsWithSubagent.add(traceId);
+    for (const type of types) {
+      subagentSpawns[type] = (subagentSpawns[type] ?? 0) + 1;
     }
   }
   const { counts: loopDispatchedRuns, filesRead } = await readLoopRuns(opts.cwds ?? []);
   const totalSkillInvocations = Object.values(skillInvocations).reduce((a, b) => a + b, 0);
   const totalSubagentSpawns = Object.values(subagentSpawns).reduce((a, b) => a + b, 0);
   const totalLoopDispatchedRuns = Object.values(loopDispatchedRuns).reduce((a, b) => a + b, 0);
+  let skillTelemetrySessions = 0;
+  let skillTelemetryUnsupportedSessions = 0;
+  let skillTelemetryUnknownSessions = 0;
+  for (const traceId of sessions) {
+    const capability = sessionCapabilities.get(traceId) ?? "unknown";
+    if (capability === "supported") skillTelemetrySessions += 1;
+    else if (capability === "unsupported") skillTelemetryUnsupportedSessions += 1;
+    else skillTelemetryUnknownSessions += 1;
+  }
   return {
-    sessionCount: sessions.size,
+    executionGroupCount: sessions.size,
+    identifiedSessionCount: identifiedSessions.size,
+    unassignedTraceCount: unassignedTraceIds.size,
+    sessionIdentityConflicts: conflicts,
     sessionsWithSkill: sessionsWithSkill.size,
-    skillPenetration: sessions.size === 0 ? 0 : sessionsWithSkill.size / sessions.size,
+    skillPenetration: skillTelemetrySessions === 0 ? null : sessionsWithSkill.size / skillTelemetrySessions,
+    skillTelemetryStatus: telemetryStatus(
+      skillTelemetrySessions,
+      skillTelemetryUnsupportedSessions,
+      skillTelemetryUnknownSessions
+    ),
+    skillTelemetrySessions,
+    sessionsWithMaterializedSkills: sessionsWithMaterializedSkills.size,
+    sessionsWithSkillFileReference: sessionsWithSkillFileReference.size,
     skillInvocations,
     totalSkillInvocations,
     subagentSpawns,
@@ -106,16 +395,27 @@ async function analyzeAdoption(spans, opts = {}) {
 }
 
 // src/otlp.ts
+import {
+  applyLlmSpanOtlpAttributes,
+  OPENINFERENCE_SPAN_KIND,
+  TOOL_NAME
+} from "@tangle-network/agent-eval/trace-attributes";
 function span(input) {
   const attributes = {
-    "openinference.span.kind": input.kind
+    [OPENINFERENCE_SPAN_KIND]: input.kind
   };
   if (input.service != null) attributes["service.name"] = input.service;
   if (input.agent != null) attributes["agent.name"] = input.agent;
-  if (input.model != null) attributes["llm.model_name"] = input.model;
-  if (input.tool != null) attributes["tool.name"] = input.tool;
-  if (input.inputTokens != null) attributes["llm.input_tokens"] = input.inputTokens;
-  if (input.outputTokens != null) attributes["llm.output_tokens"] = input.outputTokens;
+  if (input.tool != null) attributes[TOOL_NAME] = input.tool;
+  applyLlmSpanOtlpAttributes(attributes, {
+    model: input.model ?? void 0,
+    inputTokens: input.inputTokens ?? void 0,
+    outputTokens: input.outputTokens ?? void 0,
+    reasoningTokens: input.reasoningTokens ?? void 0,
+    cachedTokens: input.cachedInputTokens ?? void 0,
+    cacheWriteTokens: input.cacheWriteInputTokens ?? void 0,
+    costUsd: input.costUsd ?? void 0
+  });
   if (input.step != null) attributes.step = input.step;
   if (input.content != null && input.content.length > 0) attributes["content"] = input.content;
   if (input.extra) Object.assign(attributes, input.extra);
@@ -145,7 +445,7 @@ function toOpenInferenceSpan(s) {
     span_id: s.span_id,
     parent_span_id: s.parent_span_id ?? "",
     name: s.name,
-    kind: typeof a["openinference.span.kind"] === "string" ? a["openinference.span.kind"] : "CHAIN",
+    kind: typeof a[OPENINFERENCE_SPAN_KIND] === "string" ? a[OPENINFERENCE_SPAN_KIND] : "CHAIN",
     start_time: s.start_time,
     end_time: s.end_time,
     status: { code: s.status.code, message: s.status.message ?? "" },
@@ -168,20 +468,56 @@ async function writeOtlpFile(spans, outPath) {
   return path;
 }
 
+// src/execution.ts
+import {
+  summarizeExecution
+} from "@tangle-network/agent-eval/contract";
+import {
+  otlpRowsToRunRecords,
+  otlpToRunRecords
+} from "@tangle-network/agent-eval/traces";
+function runOptions(opts) {
+  return {
+    experimentId: opts.experimentId ?? "traces-observed",
+    candidateId: opts.candidateId ?? "observed",
+    fallbackModel: "unknown@otlp"
+  };
+}
+function* openInferenceRows(spans) {
+  for (const item of spans) yield toOpenInferenceSpan(item);
+}
+function summarizeOtlpExecution(otlpJsonl, opts = {}) {
+  const runs = otlpToRunRecords(otlpJsonl, runOptions(opts));
+  return summarizeExecution({ runs });
+}
+function summarizeSpanExecution(spans, opts = {}) {
+  if (spans.length === 0) throw new Error("summarizeSpanExecution: no spans to summarize");
+  return summarizeExecution({
+    runs: otlpRowsToRunRecords(openInferenceRows(spans), runOptions(opts))
+  });
+}
+
 // src/analyze.ts
 import { buildDefaultAnalystRegistry } from "@tangle-network/agent-eval/analyst";
 import { OtlpFileTraceStore } from "@tangle-network/agent-eval/traces";
-var DETERMINISTIC_VIEW_CEILING = 256 * 1024 * 1024;
+var GENERATED_TRACE_FILE_CEILING = 512 * 1024 * 1024;
 async function analyzeSpans(spans, opts = {}) {
   if (spans.length === 0) throw new Error("analyzeSpans: no spans to analyze");
   const otlpPath = await writeOtlpFile(spans, opts.otlpOutPath);
   const runId = opts.runId ?? `traces-${Date.now()}`;
-  const detStore = new OtlpFileTraceStore({ path: otlpPath, perCallByteCeiling: DETERMINISTIC_VIEW_CEILING });
+  const execution = summarizeSpanExecution(spans, {
+    experimentId: runId
+  });
+  const detStore = new OtlpFileTraceStore({
+    path: otlpPath,
+    maxFileBytes: GENERATED_TRACE_FILE_CEILING,
+    perCallByteCeiling: GENERATED_TRACE_FILE_CEILING
+  });
   await detStore.ensureIndexed();
   const detRegistry = opts.registry ?? buildDefaultAnalystRegistry({ registry: { log: opts.log } });
   const result = await detRegistry.run(runId, { traceStore: detStore });
   if (opts.ai) {
-    const agStore = new OtlpFileTraceStore({ path: otlpPath });
+    const agStore = new OtlpFileTraceStore({ path: otlpPath, maxFileBytes: GENERATED_TRACE_FILE_CEILING });
     await agStore.ensureIndexed();
     const agRegistry = buildDefaultAnalystRegistry({
       ai: opts.ai,
@@ -196,42 +532,32 @@ async function analyzeSpans(spans, opts = {}) {
     result.per_analyst.push(...agResult.per_analyst);
     result.total_cost_usd += agResult.total_cost_usd;
   }
-  return { otlpPath, result };
+  return { otlpPath, execution, result };
 }
 
-// src/attributes.ts
-var ATTR = {
-  /** = the trace/session id. Wire contract (dedup linkage). */
-  SESSION_ID: "tangle.sessionId",
-  /** "cli" marks a CLI upload so the platform can drop a re-upload of a session
-   *  that also streamed live. Wire contract. */
-  INGEST_SOURCE: "tangle.ingest_source",
-  HARNESS: "tangle.harness",
-  CWD: "tangle.cwd",
-  /** THE per-session grouping key the spine derives subjects from
-   *  (`deriveSubjectKey` reads `tangle.subject.key` first). Resolves to the git
-   *  remote (host/owner/repo) when readable, else the cwd path basename. */
-  SUBJECT_KEY: "tangle.subject.key",
-  /** Normalized git remote (e.g. `github.com/tangle-network/agent-dev-container`). */
-  GIT_REPOSITORY: "git.repository",
-  /** Current branch at conversion time. */
-  GIT_BRANCH_NAME: "git.branch",
-  /** HEAD short sha at conversion time. */
-  GIT_COMMIT: "git.commit",
-  /** How traces resolved the session cwd: recorded cwd, repaired cwd, or span path. */
-  REPO_RESOLUTION_SOURCE: "traces.repo_resolution_source",
-  GIT_BRANCH: "tangle.git_branch",
-  HOST: "tangle.host",
-  /** Basename of the session file. (Renamed from the ambiguous `tangle.source`,
-   *  which collided with `tangle.ingest_source`.) */
-  SESSION_FILE: "tangle.session_file",
-  UPLOADED_AT: "tangle.uploaded_at",
-  UPLOADER: "tangle.uploader",
-  REDACTION_VERSION: "redaction.version",
-  REDACTION_COUNT: "redaction.count"
-};
-var INGEST_SOURCE_CLI = "cli";
-var DEFAULT_HARNESS = "claude-code";
+// src/adapters/conversation.ts
+var CONTENT_CAP = 8e3;
+function capText(raw) {
+  const t = raw.trim();
+  if (t.length <= CONTENT_CAP) return t;
+  return `${t.slice(0, CONTENT_CAP)}\u2026 [+${t.length - CONTENT_CAP} chars]`;
+}
+var ACTOR_ATTR = "tangle.actor";
+function userPromptSpan(o) {
+  return span({
+    traceId: o.traceId,
+    spanId: o.spanId,
+    parentSpanId: o.parentSpanId,
+    name: "user.prompt",
+    kind: "CHAIN",
+    startTime: o.startTime,
+    service: o.service ?? null,
+    agent: o.agent ?? null,
+    step: o.step,
+    content: o.content,
+    extra: { [ACTOR_ATTR]: o.actor ?? "human" }
+  });
+}
 
 // src/time.ts
 function parseIsoToEpochMs(ts) {
@@ -263,73 +589,238 @@ var KIND = {
 };
 async function toRuntimeStore(spans) {
   const store = new InMemoryTraceStore();
-  const runIds = /* @__PURE__ */ new Set();
+  const runs = /* @__PURE__ */ new Map();
+  for (const item of spans) {
+    const startedAt = parseIsoToEpochMs(item.start_time);
+    const endedAt = parseIsoToEpochMs(item.end_time);
+    const current = runs.get(item.trace_id);
+    runs.set(item.trace_id, current ? {
+      startedAt: Math.min(current.startedAt, startedAt),
+      endedAt: Math.max(current.endedAt, endedAt),
+      failed: current.failed || item.status.code === "ERROR"
+    } : { startedAt, endedAt, failed: item.status.code === "ERROR" });
+  }
+  for (const [runId, run] of runs) {
+    await store.appendRun({
+      runId,
+      scenarioId: "session",
+      startedAt: run.startedAt,
+      endedAt: run.endedAt,
+      status: run.failed ? "failed" : "completed"
+    });
+  }
   for (const s of spans) {
-    if (!runIds.has(s.trace_id)) {
-      runIds.add(s.trace_id);
-      await store.appendRun({ runId: s.trace_id, scenarioId: "session" });
-    }
     const kind = KIND[s.attributes["openinference.span.kind"]] ?? "custom";
+    const startedAt = parseIsoToEpochMs(s.start_time);
+    const endedAt = parseIsoToEpochMs(s.end_time);
     const base = {
       spanId: s.span_id,
       parentSpanId: s.parent_span_id ?? void 0,
       runId: s.trace_id,
       name: s.name,
-      startedAt: parseIsoToEpochMs(s.start_time),
-      endedAt: parseIsoToEpochMs(s.end_time),
+      startedAt,
+      endedAt,
       status: s.status.code === "ERROR" ? "error" : "ok",
       error: s.status.message,
       attributes: s.attributes
     };
+    const tool = kind === "tool" ? toolArgumentsFromAttributes(s.attributes) : void 0;
     const span2 = kind === "tool" ? {
       ...base,
       kind: "tool",
       toolName: String(s.attributes["tool.name"] ?? "tool"),
-      args: s.attributes.content ?? ""
+      args: tool.args,
+      argsCaptured: tool.argsCaptured,
+      latencyMs: Math.max(0, endedAt - startedAt)
     } : { ...base, kind };
     await store.appendSpan(span2);
   }
-  return { store, runIds: [...runIds] };
+  return { store, runIds: [...runs.keys()] };
 }
 
 // src/pipelines.ts
 import { computeToolUseMetrics } from "@tangle-network/agent-eval";
-import { stuckLoopView } from "@tangle-network/agent-eval/pipelines";
+import {
+  failureClusterView,
+  stuckLoopView
+} from "@tangle-network/agent-eval/pipelines";
 async function runPipelines(spans, opts = {}) {
   const { store, runIds } = await toRuntimeStore(spans);
   const loopEligible = spans.filter((item) => item.attributes["traces.expected_blocking"] !== true);
   const { store: loopStore } = await toRuntimeStore(loopEligible);
-  const stuckLoops = await stuckLoopView(loopStore, { minOccurrences: opts.minLoopOccurrences ?? 3 });
-  const toolUse = await Promise.all(runIds.map((runId) => computeToolUseMetrics(store, runId)));
-  return { stuckLoops, toolUse };
+  const [stuckLoops, failureClusters, toolUse] = await Promise.all([
+    stuckLoopView(loopStore, { minOccurrences: opts.minLoopOccurrences ?? 3 }),
+    failureClusterView(store),
+    Promise.all(runIds.map((runId) => computeToolUseMetrics(store, runId)))
+  ]);
+  return { stuckLoops, failureClusters, toolUse };
 }
 
-// src/adapters/conversation.ts
-var CONTENT_CAP = 8e3;
-function capText(raw) {
-  const t = raw.trim();
-  if (t.length <= CONTENT_CAP) return t;
-  return `${t.slice(0, CONTENT_CAP)}\u2026 [+${t.length - CONTENT_CAP} chars]`;
+// src/integrity.ts
+import { createHash as createHash2 } from "crypto";
+var receiptStates = /* @__PURE__ */ new WeakMap();
+function receiptIdentity(receipt) {
+  return [
+    receipt.sourcePath,
+    receipt.lineNumber,
+    receipt.byteOffset,
+    receipt.byteLength,
+    receipt.sha256
+  ];
 }
-var ACTOR_ATTR = "tangle.actor";
-function userPromptSpan(o) {
-  return span({
-    traceId: o.traceId,
-    spanId: o.spanId,
-    parentSpanId: o.parentSpanId,
-    name: "user.prompt",
-    kind: "CHAIN",
-    startTime: o.startTime,
-    service: o.service ?? null,
-    agent: o.agent ?? null,
-    step: o.step,
-    content: o.content,
-    extra: { [ACTOR_ATTR]: o.actor ?? "human" }
-  });
+function receiptKey(receipt) {
+  return JSON.stringify(receiptIdentity(receipt));
+}
+function stateFor(ref, current) {
+  let state = receiptStates.get(ref);
+  if (!state || state.corruptions !== current) {
+    state = {
+      corruptions: current,
+      seen: new Set(current.map(receiptKey))
+    };
+    receiptStates.set(ref, state);
+  }
+  return state;
+}
+function recordSessionCorruption(ref, receipt) {
+  const current = ref.integrity?.corruptions ?? [];
+  const corruption = { ...receipt, harness: ref.harness, sessionId: ref.sessionId };
+  const state = stateFor(ref, current);
+  const key = receiptKey(receipt);
+  if (state.seen.has(key)) return;
+  if (ref.integrity) {
+    ref.integrity.corruptions.push(corruption);
+  } else {
+    ref.integrity = { status: "degraded_not_lossless", corruptions: [corruption] };
+  }
+  state.seen.add(key);
+  state.corruptions = ref.integrity.corruptions;
+}
+function sessionJsonlOptions(ref, options = {}) {
+  if (options.corruptionMode === "strict") return { mode: "strict" };
+  return {
+    mode: "recover",
+    onCorruption: (receipt) => recordSessionCorruption(ref, receipt)
+  };
+}
+function sessionIntegrityAttributes(ref) {
+  if (!ref.integrity) return {};
+  return {
+    [ATTR.SESSION_INTEGRITY]: ref.integrity.status,
+    [ATTR.CORRUPTION_COUNT]: ref.integrity.corruptions.length,
+    [ATTR.CORRUPTION_DIGEST]: corruptionDigest(ref.integrity.corruptions),
+    [ATTR.RAW_SOURCE_RETENTION]: "local_source_only"
+  };
+}
+function corruptionDigest(receipts) {
+  const hash2 = createHash2("sha256");
+  for (const receipt of receipts) {
+    hash2.update(JSON.stringify(receiptIdentity(receipt)));
+    hash2.update("\n");
+  }
+  return `sha256:${hash2.digest("hex")}`;
+}
+function receiptSpanId(parentSpanId, receipt) {
+  const digest = createHash2("sha256").update(JSON.stringify(receiptIdentity(receipt))).digest("hex");
+  return `${parentSpanId}:corruption:${digest}`;
+}
+function stampSessionIntegrity(ref, spans) {
+  if (!ref.integrity) return;
+  const parent = spans.find((item) => item.parent_span_id === null) ?? spans[0];
+  if (!parent) return;
+  const sessionId = parent.trace_id;
+  for (const receipt of ref.integrity.corruptions) {
+    receipt.harness = ref.harness;
+    receipt.sessionId = sessionId;
+  }
+  const attributes = sessionIntegrityAttributes(ref);
+  Object.assign(parent.attributes, attributes);
+  const existingSpanIds = new Set(spans.map((item) => item.span_id));
+  for (const receipt of ref.integrity.corruptions) {
+    const spanId = receiptSpanId(parent.span_id, receipt);
+    if (existingSpanIds.has(spanId)) continue;
+    spans.push(span({
+      traceId: parent.trace_id,
+      spanId,
+      parentSpanId: parent.span_id,
+      name: "source.corruption.receipt",
+      kind: "CHAIN",
+      startTime: parent.start_time,
+      endTime: parent.start_time,
+      status: "ERROR",
+      service: typeof parent.attributes["service.name"] === "string" ? parent.attributes["service.name"] : ref.harness,
+      extra: {
+        [ATTR.SESSION_INTEGRITY]: ref.integrity.status,
+        [ATTR.CORRUPTION_RECEIPT_VERSION]: receipt.receiptVersion,
+        [ATTR.CORRUPTION_RECEIPT_KIND]: receipt.kind,
+        [ATTR.CORRUPTION_SOURCE_PATH]: receipt.sourcePath,
+        [ATTR.CORRUPTION_LINE_NUMBER]: receipt.lineNumber,
+        [ATTR.CORRUPTION_BYTE_OFFSET]: receipt.byteOffset,
+        [ATTR.CORRUPTION_BYTE_LENGTH]: receipt.byteLength,
+        [ATTR.CORRUPTION_SHA256]: receipt.sha256,
+        [ATTR.RAW_SOURCE_RETENTION]: "local_source_only"
+      }
+    }));
+    existingSpanIds.add(spanId);
+  }
+}
+
+// src/json.ts
+import { readdir, readFile as readFile2 } from "fs/promises";
+var JsonSourceError = class extends Error {
+  sourcePath;
+  kind;
+  code;
+  constructor(sourcePath, kind, cause) {
+    super(
+      kind === "parse" ? `Invalid JSON at ${sourcePath}` : `Unable to read JSON source at ${sourcePath}`,
+      { cause }
+    );
+    this.name = "JsonSourceError";
+    this.sourcePath = sourcePath;
+    this.kind = kind;
+    this.code = errorCode(cause);
+  }
+};
+function errorCode(error) {
+  return error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function pathSafeParseCause(cause) {
+  if (!(cause instanceof Error)) return cause;
+  const location = cause.message.match(/(?:at position \d+(?: \(line \d+ column \d+\))?|line \d+ column \d+)/i)?.[0];
+  cause.message = location ? `JSON parse failed ${location}` : "JSON parse failed";
+  cause.stack = `${cause.name}: ${cause.message}`;
+  return cause;
+}
+function isMissingPathError(error) {
+  return errorCode(error) === "ENOENT";
+}
+function isMissingJsonSource(error) {
+  return error instanceof JsonSourceError && error.kind === "read" && isMissingPathError(error);
+}
+async function readJsonFile(path) {
+  let raw;
+  try {
+    raw = await readFile2(path, "utf8");
+  } catch (error) {
+    throw new JsonSourceError(path, "read", error);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new JsonSourceError(path, "parse", pathSafeParseCause(error));
+  }
+}
+async function listJsonFiles(path) {
+  try {
+    return (await readdir(path)).filter((file) => file.endsWith(".json"));
+  } catch (error) {
+    throw new JsonSourceError(path, "read", error);
+  }
 }
 
 // src/adapters/amp.ts
-import { readdir, readFile as readFile2, stat } from "fs/promises";
+import { readdir as readdir2, stat } from "fs/promises";
 import { homedir } from "os";
 import { basename, join as join2 } from "path";
 var SERVICE = "amp";
@@ -348,9 +839,10 @@ var AmpAdapter = class {
   async locate(opts = {}) {
     let files;
     try {
-      files = await readdir(this.threadsRoot());
-    } catch {
-      return [];
+      files = await readdir2(this.threadsRoot());
+    } catch (error) {
+      if (isMissingPathError(error)) return [];
+      throw error;
     }
     const refs = [];
     for (const f of files) {
@@ -359,8 +851,9 @@ var AmpAdapter = class {
       let st;
       try {
         st = await stat(path);
-      } catch {
-        continue;
+      } catch (error) {
+        if (isMissingPathError(error)) continue;
+        throw error;
       }
       if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
       if (opts.cwd) continue;
@@ -369,12 +862,7 @@ var AmpAdapter = class {
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   }
   async parse(ref) {
-    let thread;
-    try {
-      thread = JSON.parse(await readFile2(ref.path, "utf8"));
-    } catch {
-      return [];
-    }
+    const thread = await readJsonFile(ref.path);
     const traceId = thread.id ?? ref.sessionId;
     const rootId = `root:${traceId}`;
     const start = new Date(thread.created ?? 0).toISOString();
@@ -406,7 +894,6 @@ var AmpAdapter = class {
         }
       } else {
         const u = m.usage;
-        const inputTokens2 = u ? (u.inputTokens ?? 0) + (u.cacheReadInputTokens ?? 0) + (u.cacheCreationInputTokens ?? 0) || null : null;
         spans.push(
           span({
             traceId,
@@ -418,8 +905,10 @@ var AmpAdapter = class {
             service: SERVICE,
             agent: SERVICE,
             model: u?.model ?? null,
-            inputTokens: inputTokens2,
+            inputTokens: u?.inputTokens ?? null,
             outputTokens: u?.outputTokens ?? null,
+            cachedInputTokens: u?.cacheReadInputTokens ?? null,
+            cacheWriteInputTokens: u?.cacheCreationInputTokens ?? null,
             step,
             content: textOf(m.content) || null
           })
@@ -439,14 +928,17 @@ var AmpAdapter = class {
             agent: SERVICE,
             tool: b.name,
             step,
-            content: b.input != null ? JSON.stringify(b.input) : null
+            extra: toolIoAttributes({ input: b.input })
           });
           spans.push(t);
           if (b.id) toolByUseId.set(b.id, t);
           step += 1;
         } else if (b.type === "tool_result" && b.tool_use_id) {
           const t = toolByUseId.get(b.tool_use_id);
-          if (t) t.status = b.is_error === true ? { code: "ERROR", message: "tool reported error" } : { code: "OK" };
+          if (t) {
+            t.status = b.is_error === true ? { code: "ERROR", message: "tool reported error" } : { code: "OK" };
+            recordToolOutput(t, b.content ?? b.output);
+          }
         }
       }
     }
@@ -454,6 +946,108 @@ var AmpAdapter = class {
   }
 };
 
+// src/jsonl.ts
+import { isUtf8 } from "buffer";
+import { createHash as createHash3 } from "crypto";
+import { createReadStream } from "fs";
+var JsonlParseError = class extends SyntaxError {
+  sourcePath;
+  lineNumber;
+  byteOffset;
+  byteLength;
+  sha256;
+  receipt;
+  constructor(receipt) {
+    super(`Invalid JSONL at ${receipt.sourcePath}:${receipt.lineNumber}`);
+    this.name = "JsonlParseError";
+    this.sourcePath = receipt.sourcePath;
+    this.lineNumber = receipt.lineNumber;
+    this.byteOffset = receipt.byteOffset;
+    this.byteLength = receipt.byteLength;
+    this.sha256 = receipt.sha256;
+    this.receipt = receipt;
+  }
+};
+function corruptionReceipt(rawLine, path, lineNumber, byteOffset) {
+  return {
+    receiptVersion: 1,
+    kind: "jsonl_corruption",
+    status: "degraded_not_lossless",
+    sourcePath: path,
+    lineNumber,
+    byteOffset,
+    byteLength: rawLine.length,
+    sha256: createHash3("sha256").update(rawLine).digest("hex"),
+    rawBytes: "local_source_only"
+  };
+}
+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 {
+    return JSON.parse(json2);
+  } catch {
+    return handleCorruption(rawLine, path, lineNumber, byteOffset, options);
+  }
+}
+function handleCorruption(rawLine, path, lineNumber, byteOffset, options) {
+  const receipt = corruptionReceipt(rawLine, path, lineNumber, byteOffset);
+  if (options.mode === "recover") {
+    options.onCorruption(receipt);
+    return void 0;
+  }
+  throw new JsonlParseError(receipt);
+}
+async function* readJsonl(path, options = { mode: "strict" }) {
+  if (options.mode === "recover" && typeof options.onCorruption !== "function") {
+    throw new TypeError("JSONL recover mode requires an onCorruption callback");
+  }
+  const input = createReadStream(path);
+  let lineNumber = 0;
+  let byteOffset = 0;
+  let fragments = [];
+  try {
+    for await (const chunk of input) {
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      let start = 0;
+      let newline = bytes.indexOf(10);
+      while (newline !== -1) {
+        fragments.push(bytes.subarray(start, newline));
+        const rawLine = fragments.length === 1 ? fragments[0] : Buffer.concat(fragments);
+        fragments = [];
+        lineNumber += 1;
+        const parsed = parseLine(rawLine, path, lineNumber, byteOffset, options);
+        if (parsed !== void 0) yield parsed;
+        byteOffset += rawLine.length + 1;
+        start = newline + 1;
+        newline = bytes.indexOf(10, start);
+      }
+      if (start < bytes.length) fragments.push(bytes.subarray(start));
+    }
+    if (fragments.length > 0) {
+      const rawLine = fragments.length === 1 ? fragments[0] : Buffer.concat(fragments);
+      lineNumber += 1;
+      const parsed = parseLine(rawLine, path, lineNumber, byteOffset, options);
+      if (parsed !== void 0) yield parsed;
+    }
+  } finally {
+    input.destroy();
+  }
+}
+async function takeJsonl(path, limit, options = { mode: "strict" }) {
+  if (!Number.isInteger(limit) || limit < 0) throw new RangeError("limit must be a non-negative integer");
+  const rows = [];
+  if (limit === 0) return rows;
+  for await (const row of readJsonl(path, options)) {
+    rows.push(row);
+    if (rows.length === limit) break;
+  }
+  return rows;
+}
+
 // src/adapters/actor.ts
 var CMD_MARKERS = [
   "<command-name>",
@@ -471,6 +1065,10 @@ var INJECT_MARKERS = [
   // not a person. (Observed in Claude Code task/loop sessions.)
   "<task-notification>",
   "<task-prompt>",
+  // Prefix match: Codex adds attributes such as source="goal" to this tag.
+  "<codex_internal_context",
+  "<subagent_notification>",
+  "# AGENTS.md instructions for ",
   "<local-command-stdout>",
   "This session is being continued from a previous conversation",
   // Slash-command skill bodies are expanded into a user turn (no <command-name>
@@ -543,26 +1141,10 @@ function classifyReaction(text) {
 var CORRECTIVE_REACTIONS = ["correction", "frustration", "jargon", "structure"];
 
 // src/adapters/claude.ts
-import { readdir as readdir2, readFile as readFile3, stat as stat2 } from "fs/promises";
+import { readdir as readdir3, stat as stat2 } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { basename as basename2, join as join3 } from "path";
 var SERVICE2 = "claude-code";
-function parseLines(raw) {
-  const out = [];
-  for (const line of raw.split("\n")) {
-    if (!line) continue;
-    try {
-      out.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return out;
-}
-function inputTokens(u) {
-  if (!u) return null;
-  const v = (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
-  return v > 0 ? v : null;
-}
 function asBlocks(content) {
   return Array.isArray(content) ? content : [];
 }
@@ -579,96 +1161,104 @@ function stringifyToolResult(content) {
   }
   return "";
 }
-function parseClaudeStream(events, ctx) {
-  const spans = [];
-  const toolSpanByUseId = /* @__PURE__ */ new Map();
-  let step = ctx.startStep;
-  let sawUserTurn = false;
-  for (const ev of events) {
-    const ts = ev.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
-    const uid = ev.uuid ?? `${ctx.idPrefix}step${step}`;
-    if (ev.type === "assistant" && ev.message) {
-      const llmId = `${ctx.idPrefix}${uid}`;
-      spans.push(
-        span({
+function createClaudeStream(startStep) {
+  return { spans: [], toolSpanByUseId: /* @__PURE__ */ new Map(), step: startStep, sawUserTurn: false };
+}
+function consumeClaudeEvent(ev, ctx, state) {
+  const ts = ev.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
+  const uid = ev.uuid ?? `${ctx.idPrefix}step${state.step}`;
+  if (ev.type === "assistant" && ev.message) {
+    const llmId = `${ctx.idPrefix}${uid}`;
+    state.spans.push(
+      span({
+        traceId: ctx.traceId,
+        spanId: llmId,
+        parentSpanId: ctx.rootParent,
+        name: "llm.turn",
+        kind: "LLM",
+        startTime: ts,
+        service: SERVICE2,
+        agent: ctx.agent,
+        model: ev.message.model ?? null,
+        inputTokens: ev.message.usage?.input_tokens ?? null,
+        outputTokens: ev.message.usage?.output_tokens ?? null,
+        cachedInputTokens: ev.message.usage?.cache_read_input_tokens ?? null,
+        cacheWriteInputTokens: ev.message.usage?.cache_creation_input_tokens ?? null,
+        step: state.step,
+        content: textOf2(ev.message.content) || null
+      })
+    );
+    state.step += 1;
+    let toolIdx = 0;
+    for (const block of asBlocks(ev.message.content)) {
+      if (block.type !== "tool_use" || !block.name) continue;
+      const toolSpan = span({
+        traceId: ctx.traceId,
+        spanId: `${ctx.idPrefix}${uid}:tool:${toolIdx}`,
+        parentSpanId: llmId,
+        name: `tool.${block.name}`,
+        kind: "TOOL",
+        startTime: ts,
+        service: SERVICE2,
+        agent: ctx.agent,
+        tool: block.name,
+        step: state.step,
+        extra: toolIoAttributes({ input: block.input })
+      });
+      state.spans.push(toolSpan);
+      if (block.id) state.toolSpanByUseId.set(block.id, toolSpan);
+      toolIdx += 1;
+      state.step += 1;
+    }
+  } else if (ev.type === "user" && ev.message) {
+    const prompt = textOf2(ev.message.content);
+    if (prompt) {
+      const actor = claudeActor({
+        text: prompt,
+        isSidechain: ev.isSidechain,
+        userType: ev.userType ?? null,
+        isFirstUserTurn: !state.sawUserTurn
+      });
+      state.sawUserTurn = true;
+      state.spans.push(
+        userPromptSpan({
           traceId: ctx.traceId,
-          spanId: llmId,
+          spanId: `${ctx.idPrefix}${uid}:user`,
           parentSpanId: ctx.rootParent,
-          name: "llm.turn",
-          kind: "LLM",
           startTime: ts,
           service: SERVICE2,
           agent: ctx.agent,
-          model: ev.message.model ?? null,
-          inputTokens: inputTokens(ev.message.usage),
-          outputTokens: ev.message.usage?.output_tokens ?? null,
-          step,
-          content: textOf2(ev.message.content) || null
+          step: state.step,
+          content: prompt,
+          actor
         })
       );
-      step += 1;
-      let toolIdx = 0;
-      for (const block of asBlocks(ev.message.content)) {
-        if (block.type !== "tool_use" || !block.name) continue;
-        const toolSpan = span({
-          traceId: ctx.traceId,
-          spanId: `${ctx.idPrefix}${uid}:tool:${toolIdx}`,
-          parentSpanId: llmId,
-          name: `tool.${block.name}`,
-          kind: "TOOL",
-          startTime: ts,
-          service: SERVICE2,
-          agent: ctx.agent,
-          tool: block.name,
-          step,
-          content: block.input != null ? JSON.stringify(block.input) : null
-        });
-        spans.push(toolSpan);
-        if (block.id) toolSpanByUseId.set(block.id, toolSpan);
-        toolIdx += 1;
-        step += 1;
-      }
-    } else if (ev.type === "user" && ev.message) {
-      const prompt = textOf2(ev.message.content);
-      if (prompt) {
-        const actor = claudeActor({
-          text: prompt,
-          isSidechain: ev.isSidechain,
-          userType: ev.userType ?? null,
-          isFirstUserTurn: !sawUserTurn
-        });
-        sawUserTurn = true;
-        spans.push(
-          userPromptSpan({
-            traceId: ctx.traceId,
-            spanId: `${ctx.idPrefix}${uid}:user`,
-            parentSpanId: ctx.rootParent,
-            startTime: ts,
-            service: SERVICE2,
-            agent: ctx.agent,
-            step,
-            content: prompt,
-            actor
-          })
-        );
-        step += 1;
-      }
-      for (const block of asBlocks(ev.message.content)) {
-        if (block.type !== "tool_result" || !block.tool_use_id) continue;
-        backfillResult(toolSpanByUseId.get(block.tool_use_id), ts, block.is_error === true, stringifyToolResult(block.content));
-      }
-    } else if (ev.type === "attachment" && ev.attachment?.type === "tool_result" && ev.attachment.toolUseID) {
-      const err = typeof ev.attachment.exitCode === "number" && ev.attachment.exitCode !== 0;
-      backfillResult(toolSpanByUseId.get(ev.attachment.toolUseID), ts, err, ev.attachment.stderr ?? "");
+      state.step += 1;
+    }
+    for (const block of asBlocks(ev.message.content)) {
+      if (block.type !== "tool_result" || !block.tool_use_id) continue;
+      backfillResult(
+        state.toolSpanByUseId.get(block.tool_use_id),
+        ts,
+        block.is_error === true,
+        block.content
+      );
     }
+  } else if (ev.type === "attachment" && ev.attachment?.type === "tool_result" && ev.attachment.toolUseID) {
+    const err = typeof ev.attachment.exitCode === "number" && ev.attachment.exitCode !== 0;
+    backfillResult(state.toolSpanByUseId.get(ev.attachment.toolUseID), ts, err, ev.attachment.stderr ?? "");
   }
-  return { spans, toolSpanByUseId, nextStep: step };
 }
-function backfillResult(s, endTime, isError, message) {
+function finishClaudeStream(state) {
+  return { spans: state.spans, toolSpanByUseId: state.toolSpanByUseId, nextStep: state.step };
+}
+function backfillResult(s, endTime, isError, output) {
   if (!s) return;
   s.end_time = endTime;
   const code = isError ? "ERROR" : "OK";
   s.status = { code };
+  recordToolOutput(s, output);
+  const message = stringifyToolResult(output);
   if (isError && message) s.status.message = message.slice(0, 500);
 }
 var ClaudeAdapter = class {
@@ -681,18 +1271,20 @@ var ClaudeAdapter = class {
     const root = this.root();
     let projectDirs;
     try {
-      projectDirs = await readdir2(root);
-    } catch {
-      return [];
+      projectDirs = await readdir3(root);
+    } catch (error) {
+      if (isMissingPathError(error)) return [];
+      throw error;
     }
     const refs = [];
     for (const dir of projectDirs) {
       const dirPath = join3(root, dir);
       let files;
       try {
-        files = await readdir2(dirPath);
-      } catch {
-        continue;
+        files = await readdir3(dirPath);
+      } catch (error) {
+        if (isMissingPathError(error)) continue;
+        throw error;
       }
       for (const f of files) {
         if (!f.endsWith(".jsonl")) continue;
@@ -700,8 +1292,9 @@ var ClaudeAdapter = class {
         let st;
         try {
           st = await stat2(path);
-        } catch {
-          continue;
+        } catch (error) {
+          if (isMissingPathError(error)) continue;
+          throw error;
         }
         if (!st.isFile()) continue;
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
@@ -712,11 +1305,37 @@ var ClaudeAdapter = class {
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   }
-  async parse(ref) {
-    const raw = await readFile3(ref.path, "utf8");
-    const events = parseLines(raw);
-    const traceId = events.find((e) => e.sessionId)?.sessionId ?? ref.sessionId;
+  async parse(ref, options = {}) {
+    const sourceTraceId = ref.sessionId;
+    const sourceRootId = `root:${sourceTraceId}`;
+    const ctx = {
+      traceId: sourceTraceId,
+      agent: SERVICE2,
+      startStep: 0,
+      idPrefix: "",
+      rootParent: sourceRootId
+    };
+    const state = createClaudeStream(ctx.startStep);
+    let discoveredTraceId;
+    let firstTimestamp;
+    let lastTimestamp;
+    let sawEvent = false;
+    for await (const event of readJsonl(ref.path, sessionJsonlOptions(ref, options))) {
+      if (!sawEvent) {
+        firstTimestamp = event.timestamp;
+        sawEvent = true;
+      }
+      lastTimestamp = event.timestamp;
+      if (!discoveredTraceId && event.sessionId) discoveredTraceId = event.sessionId;
+      consumeClaudeEvent(event, ctx, state);
+    }
+    const main = finishClaudeStream(state);
+    const traceId = discoveredTraceId ?? sourceTraceId;
     const rootId = `root:${traceId}`;
+    for (const item of main.spans) {
+      item.trace_id = traceId;
+      if (item.parent_span_id === sourceRootId) item.parent_span_id = rootId;
+    }
     const spans = [
       span({
         traceId,
@@ -724,55 +1343,53 @@ var ClaudeAdapter = class {
         parentSpanId: null,
         name: "session",
         kind: "AGENT",
-        startTime: events[0]?.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-        endTime: events.at(-1)?.timestamp,
+        startTime: firstTimestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        endTime: lastTimestamp,
         service: SERVICE2,
         agent: SERVICE2
-      })
+      }),
+      ...main.spans
     ];
-    const main = parseClaudeStream(events, {
-      traceId,
-      agent: SERVICE2,
-      startStep: 0,
-      idPrefix: "",
-      rootParent: rootId
-    });
-    spans.push(...main.spans);
-    await this.foldSubagents(ref, traceId, main, spans);
+    await this.foldSubagents(ref, traceId, main, spans, options);
     return spans;
   }
   /** Parse `<session>/subagents/agent-*.jsonl`, parenting each under its Agent call. */
-  async foldSubagents(ref, traceId, main, out) {
+  async foldSubagents(ref, traceId, main, out, options) {
     const subDir = join3(ref.path.replace(/\.jsonl$/, ""), "subagents");
     let files;
     try {
-      files = await readdir2(subDir);
-    } catch {
-      return;
+      files = await readdir3(subDir);
+    } catch (error) {
+      if (isMissingPathError(error)) return;
+      throw error;
     }
     let step = main.nextStep;
-    for (const f of files) {
-      if (!f.endsWith(".jsonl")) continue;
-      const hash2 = basename2(f, ".jsonl");
+    for (const file of files) {
+      if (!file.endsWith(".jsonl")) continue;
+      const hash2 = basename2(file, ".jsonl");
+      const metaPath = join3(subDir, `${hash2}.meta.json`);
       let meta = {};
       try {
-        meta = JSON.parse(await readFile3(join3(subDir, `${hash2}.meta.json`), "utf8"));
-      } catch {
+        meta = await readJsonFile(metaPath);
+      } catch (error) {
+        if (!isMissingJsonSource(error)) throw error;
       }
       const parent = meta.toolUseId && main.toolSpanByUseId.get(meta.toolUseId)?.span_id || `root:${traceId}`;
-      let raw;
-      try {
-        raw = await readFile3(join3(subDir, f), "utf8");
-      } catch {
-        continue;
-      }
-      const parsed = parseClaudeStream(parseLines(raw), {
+      const ctx = {
         traceId,
         agent: meta.agentType ? `subagent:${meta.agentType}` : "subagent",
         startStep: step,
         idPrefix: `${hash2}:`,
         rootParent: parent
-      });
+      };
+      const state = createClaudeStream(ctx.startStep);
+      for await (const event of readJsonl(
+        join3(subDir, file),
+        sessionJsonlOptions(ref, options)
+      )) {
+        consumeClaudeEvent(event, ctx, state);
+      }
+      const parsed = finishClaudeStream(state);
       out.push(...parsed.spans);
       step = parsed.nextStep;
     }
@@ -780,21 +1397,11 @@ var ClaudeAdapter = class {
 };
 
 // src/adapters/codex.ts
-import { readdir as readdir3, readFile as readFile4, stat as stat3 } from "fs/promises";
+import { readdir as readdir4, stat as stat3 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import { basename as basename3, join as join4 } from "path";
 var SERVICE3 = "codex";
-function parseLines2(raw) {
-  const out = [];
-  for (const line of raw.split("\n")) {
-    if (!line) continue;
-    try {
-      out.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return out;
-}
+var SESSION_HEAD_LINES = 40;
 function contentToString(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
@@ -821,6 +1428,28 @@ function toolInputToString(input) {
   if (input == null) return void 0;
   return JSON.stringify(input);
 }
+var CODEX_SESSION_ID = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+function sessionIds(value) {
+  return [...new Set(contentToString(value).match(CODEX_SESSION_ID) ?? [])];
+}
+function spawnedSessionIds(output) {
+  const text = contentToString(output);
+  const ids = [...text.matchAll(/["']?agent_id["']?\s*:\s*["']([0-9a-f-]{36})["']/gi)].map((match) => match[1]).filter((id) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id));
+  return [...new Set(ids)];
+}
+function multiAgentOperation(name) {
+  const prefix = "multi_agent_v1__";
+  return name.startsWith(prefix) ? name.slice(prefix.length) : null;
+}
+function setAgentSessionIds(toolSpan, ids) {
+  if (ids.length === 0) return;
+  const unique = [...new Set(ids)];
+  toolSpan.attributes["traces.codex.agent_session_ids"] = JSON.stringify(unique);
+  toolSpan.attributes["traces.codex.agent_session_count"] = unique.length;
+  if (toolSpan.attributes["traces.codex.agent_operation"] === "spawn_agent") {
+    toolSpan.attributes["traces.child_session_ids"] = JSON.stringify(unique);
+  }
+}
 var verificationCommand = /\b(?:pnpm|npm|yarn|bun)\s+(?:run\s+)?(?:test|typecheck|lint|build|check)(?::[A-Za-z0-9:_-]+)?\b|\b(?:vitest|jest|pytest|tsc|biome|eslint|sha256sum|pdfinfo|pdftotext)\b|\bgo\s+test\b|\bcargo\s+(?:test|check|clippy|build)\b|\bgit\s+(?:status|diff|show|merge-tree)\b|\bgh-drew\s+pr\s+(?:view|checks)\b/i;
 function hasReadOnlyCurl(input) {
   if (!/\bcurl\b/i.test(input)) return false;
@@ -840,33 +1469,37 @@ function isExpectedBlockingTool(name, input) {
 async function* walkRollouts(root) {
   let years;
   try {
-    years = await readdir3(root);
-  } catch {
-    return;
+    years = await readdir4(root);
+  } catch (error) {
+    if (isMissingPathError(error)) return;
+    throw error;
   }
   for (const y of years) {
     const yp = join4(root, y);
     let months;
     try {
-      months = await readdir3(yp);
-    } catch {
-      continue;
+      months = await readdir4(yp);
+    } catch (error) {
+      if (isMissingPathError(error)) continue;
+      throw error;
     }
     for (const m of months) {
       const mp = join4(yp, m);
       let days;
       try {
-        days = await readdir3(mp);
-      } catch {
-        continue;
+        days = await readdir4(mp);
+      } catch (error) {
+        if (isMissingPathError(error)) continue;
+        throw error;
       }
       for (const d of days) {
         const dp = join4(mp, d);
         let files;
         try {
-          files = await readdir3(dp);
-        } catch {
-          continue;
+          files = await readdir4(dp);
+        } catch (error) {
+          if (isMissingPathError(error)) continue;
+          throw error;
         }
         for (const f of files) {
           if (f.startsWith("rollout-") && f.endsWith(".jsonl")) yield join4(dp, f);
@@ -887,75 +1520,106 @@ var CodexAdapter = class {
       let st;
       try {
         st = await stat3(path);
-      } catch {
-        continue;
+      } catch (error) {
+        if (isMissingPathError(error)) continue;
+        throw error;
       }
       if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
-      const head = (await readFile4(path, "utf8").catch(() => "")).split("\n", 40);
       let cwd = null;
       let id = basename3(path).replace(/^rollout-[\dT-]+-/, "").replace(/\.jsonl$/, "");
-      for (const line of head) {
-        if (!line) continue;
-        try {
-          const l = JSON.parse(line);
-          if (l.type === "session_meta" && l.payload?.id) id = l.payload.id;
-          if (!cwd && l.payload?.cwd) cwd = l.payload.cwd;
-        } catch {
-        }
+      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) {
+        if (parsed.type === "session_meta" && parsed.payload?.id) id = parsed.payload.id;
+        if (!cwd && parsed.payload?.cwd) cwd = parsed.payload.cwd;
         if (cwd) break;
       }
-      if (opts.cwd && (!cwd || !cwd.startsWith(opts.cwd))) continue;
-      refs.push({ harness: this.harness, sessionId: id, path, cwd, mtimeMs: st.mtimeMs });
+      ref.sessionId = id;
+      ref.cwd = cwd;
+      if (ref.integrity) {
+        ref.integrity.corruptions = ref.integrity.corruptions.map((receipt) => ({ ...receipt, sessionId: id }));
+      }
+      if (opts.cwd && cwd && !cwd.startsWith(opts.cwd)) continue;
+      if (opts.cwd && !cwd && !ref.integrity) continue;
+      refs.push(ref);
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   }
-  async parse(ref) {
-    const lines = parseLines2(await readFile4(ref.path, "utf8"));
-    const meta = lines.find((l) => l.type === "session_meta");
+  async parse(ref, options = {}) {
+    const jsonl2 = sessionJsonlOptions(ref, options);
+    const head = await takeJsonl(ref.path, SESSION_HEAD_LINES, jsonl2);
+    let first = head[0];
+    let meta = head.find((line) => line.type === "session_meta");
+    let model = head.find((line) => line.type === "turn_context")?.payload?.model ?? null;
+    if (!first || !meta) {
+      for await (const line of readJsonl(ref.path, jsonl2)) {
+        first ??= line;
+        if (!meta && line.type === "session_meta") meta = line;
+        if (!model && line.type === "turn_context") model = line.payload?.model ?? null;
+        if (first && meta) break;
+      }
+    }
     const traceId = meta?.payload?.id ?? ref.sessionId;
-    const model = lines.find((l) => l.type === "turn_context")?.payload?.model ?? null;
+    const spawnMeta = meta?.payload?.source?.subagent?.thread_spawn;
+    const parentSessionId = meta?.payload?.parent_thread_id ?? spawnMeta?.parent_thread_id;
+    const sessionRole = parentSessionId || meta?.payload?.thread_source === "subagent" ? "child" : "operator";
     const rootId = `root:${traceId}`;
-    const spans = [
-      span({
-        traceId,
-        spanId: rootId,
-        parentSpanId: null,
-        name: "session",
-        kind: "AGENT",
-        startTime: meta?.timestamp ?? lines[0]?.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-        endTime: lines.at(-1)?.timestamp,
-        service: SERVICE3,
-        agent: SERVICE3,
-        model
-      })
-    ];
+    const root = span({
+      traceId,
+      spanId: rootId,
+      parentSpanId: null,
+      name: "session",
+      kind: "AGENT",
+      startTime: meta?.timestamp ?? first?.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      service: SERVICE3,
+      agent: SERVICE3,
+      model,
+      extra: {
+        "traces.session.role": sessionRole,
+        ...parentSessionId ? { "traces.parent_session_id": parentSessionId } : {},
+        ...spawnMeta?.depth != null ? { "traces.codex.agent_depth": spawnMeta.depth } : {},
+        ...meta?.payload?.agent_nickname ?? spawnMeta?.agent_nickname ? { "traces.codex.agent_nickname": meta?.payload?.agent_nickname ?? spawnMeta?.agent_nickname } : {},
+        ...meta?.payload?.agent_role ?? spawnMeta?.agent_role ? { "traces.codex.agent_role": meta?.payload?.agent_role ?? spawnMeta?.agent_role } : {},
+        ...spawnMeta?.agent_path ? { "traces.codex.agent_path": spawnMeta.agent_path } : {}
+      }
+    });
+    const spans = [root];
     const toolByCallId = /* @__PURE__ */ new Map();
     const subagentByThreadId = /* @__PURE__ */ new Map();
     let step = 0;
     let lastLlm = rootId;
     let sawUserTurn = false;
-    for (const l of lines) {
+    let lastTimestamp;
+    const awaitingModel = model ? [] : [root];
+    for await (const l of readJsonl(ref.path, jsonl2)) {
+      lastTimestamp = l.timestamp;
       const ts = l.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
-      if (l.type === "event_msg" && l.payload?.type === "token_count") {
+      if (!model && l.type === "turn_context" && l.payload?.model) {
+        model = l.payload.model;
+        for (const pending of awaitingModel) pending.attributes["llm.model_name"] = model;
+        awaitingModel.length = 0;
+      } else if (l.type === "event_msg" && l.payload?.type === "token_count") {
         const u = l.payload.info?.last_token_usage;
         if (u && (u.input_tokens || u.output_tokens)) {
           const id = `llm:${step}`;
-          spans.push(
-            span({
-              traceId,
-              spanId: id,
-              parentSpanId: rootId,
-              name: "llm.turn",
-              kind: "LLM",
-              startTime: ts,
-              service: SERVICE3,
-              agent: SERVICE3,
-              model,
-              inputTokens: u.input_tokens ?? null,
-              outputTokens: u.output_tokens ?? null,
-              step
-            })
-          );
+          const llm = span({
+            traceId,
+            spanId: id,
+            parentSpanId: rootId,
+            name: "llm.turn",
+            kind: "LLM",
+            startTime: ts,
+            service: SERVICE3,
+            agent: SERVICE3,
+            model,
+            inputTokens: u.input_tokens ?? null,
+            outputTokens: u.output_tokens ?? null,
+            reasoningTokens: u.reasoning_output_tokens ?? null,
+            cachedInputTokens: u.cached_input_tokens ?? null,
+            step
+          });
+          spans.push(llm);
+          if (!model) awaitingModel.push(llm);
           lastLlm = id;
           step += 1;
         }
@@ -967,6 +1631,7 @@ var CodexAdapter = class {
         );
         const nestedName = l.payload.type === "custom_tool_call" ? singleNestedToolName(input) : null;
         const name = classifyNestedTool(nestedName ?? outerName, input);
+        const agentOperation = multiAgentOperation(nestedName ?? outerName);
         const toolSpan = span({
           traceId,
           spanId: `tool:${callId}`,
@@ -978,14 +1643,16 @@ var CodexAdapter = class {
           agent: SERVICE3,
           tool: name,
           step,
-          content: input ?? null,
           extra: {
+            ...toolIoAttributes({ input }),
             "traces.codex.call_type": l.payload.type,
             ...name !== outerName ? { "traces.codex.outer_tool_name": outerName } : {},
             ...nestedName ? { "traces.codex.nested_tool_name": nestedName } : {},
-            ...isExpectedBlockingTool(name, input) ? { "traces.expected_blocking": true } : {}
+            ...isExpectedBlockingTool(name, input) ? { "traces.expected_blocking": true } : {},
+            ...agentOperation ? { "traces.codex.agent_operation": agentOperation } : {}
           }
         });
+        if (agentOperation && agentOperation !== "spawn_agent") setAgentSessionIds(toolSpan, sessionIds(input));
         spans.push(toolSpan);
         toolByCallId.set(callId, toolSpan);
         step += 1;
@@ -995,6 +1662,10 @@ var CodexAdapter = class {
           const { error, message } = outputIsError(l.payload.output);
           t.end_time = ts;
           t.status = error ? { code: "ERROR", message } : { code: "OK" };
+          recordToolOutput(t, l.payload.output);
+          if (t.attributes["traces.codex.agent_operation"] === "spawn_agent") {
+            setAgentSessionIds(t, spawnedSessionIds(l.payload.output));
+          }
         }
       } else if (l.type === "event_msg" && l.payload?.type === "sub_agent_activity") {
         const threadId = l.payload.agent_thread_id;
@@ -1014,12 +1685,14 @@ var CodexAdapter = class {
             agent: SERVICE3,
             tool: "Agent",
             step,
-            content: JSON.stringify({
-              subagent_type: subagentType,
-              agent_path: agentPath,
-              agent_thread_id: threadId
-            }),
             extra: {
+              ...toolIoAttributes({
+                input: {
+                  subagent_type: subagentType,
+                  agent_path: agentPath,
+                  agent_thread_id: threadId
+                }
+              }),
               "traces.codex.subagent_path": agentPath,
               "traces.codex.subagent_thread_id": threadId
             }
@@ -1081,26 +1754,16 @@ var CodexAdapter = class {
         }
       }
     }
+    root.end_time = lastTimestamp ?? root.start_time;
     return spans;
   }
 };
 
 // src/adapters/copilot.ts
-import { readdir as readdir4, readFile as readFile5, stat as stat4 } from "fs/promises";
+import { readdir as readdir5, stat as stat4 } from "fs/promises";
 import { homedir as homedir4 } from "os";
 import { join as join5 } from "path";
 var SERVICE4 = "github-copilot";
-function parseLines3(raw) {
-  const out = [];
-  for (const line of raw.split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      out.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return out;
-}
 var CopilotAdapter = class {
   harness = "github-copilot";
   aliases = ["copilot"];
@@ -1110,9 +1773,10 @@ var CopilotAdapter = class {
   async locate(opts = {}) {
     let dirs;
     try {
-      dirs = await readdir4(this.root());
-    } catch {
-      return [];
+      dirs = await readdir5(this.root());
+    } catch (error) {
+      if (isMissingPathError(error)) return [];
+      throw error;
     }
     const refs = [];
     for (const id of dirs) {
@@ -1120,8 +1784,9 @@ var CopilotAdapter = class {
       let st;
       try {
         st = await stat4(path);
-      } catch {
-        continue;
+      } catch (error) {
+        if (isMissingPathError(error)) continue;
+        throw error;
       }
       if (!st.isFile()) continue;
       if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
@@ -1130,28 +1795,23 @@ var CopilotAdapter = class {
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   }
-  async parse(ref) {
-    const events = parseLines3(await readFile5(ref.path, "utf8"));
+  async parse(ref, options = {}) {
     const traceId = ref.sessionId;
     const rootId = `root:${traceId}`;
-    const spans = [
-      span({
-        traceId,
-        spanId: rootId,
-        parentSpanId: null,
-        name: "session",
-        kind: "AGENT",
-        startTime: events[0]?.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-        endTime: events.at(-1)?.timestamp,
-        service: SERVICE4,
-        agent: SERVICE4
-      })
-    ];
+    const spans = [];
     const toolByCallId = /* @__PURE__ */ new Map();
+    let firstTimestamp;
+    let lastTimestamp;
+    let sawEvent = false;
     let step = 0;
     let lastLlm = rootId;
     let pendingInputTokens = null;
-    for (const ev of events) {
+    for await (const ev of readJsonl(ref.path, sessionJsonlOptions(ref, options))) {
+      if (!sawEvent) {
+        firstTimestamp = ev.timestamp;
+        sawEvent = true;
+      }
+      lastTimestamp = ev.timestamp;
       const ts = ev.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
       const d = ev.data ?? {};
       if (ev.type === "assistant.usage") {
@@ -1193,7 +1853,7 @@ var CopilotAdapter = class {
           agent: SERVICE4,
           tool: name,
           step,
-          content: d.arguments != null ? JSON.stringify(d.arguments) : null
+          extra: toolIoAttributes({ input: d.arguments })
         });
         spans.push(t);
         toolByCallId.set(d.toolCallId, t);
@@ -1204,15 +1864,27 @@ var CopilotAdapter = class {
           t.end_time = ts;
           const err = d.success === false;
           t.status = err ? { code: "ERROR", message: (d.error?.message ?? "").slice(0, 500) } : { code: "OK" };
+          recordToolOutput(t, d.output ?? d.result ?? d.error?.message);
         }
       }
     }
-    return spans;
+    const root = span({
+      traceId,
+      spanId: rootId,
+      parentSpanId: null,
+      name: "session",
+      kind: "AGENT",
+      startTime: firstTimestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      endTime: lastTimestamp,
+      service: SERVICE4,
+      agent: SERVICE4
+    });
+    return [root, ...spans];
   }
 };
 
 // src/adapters/factory.ts
-import { readdir as readdir5, readFile as readFile6, stat as stat5 } from "fs/promises";
+import { readdir as readdir6, stat as stat5 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { basename as basename4, join as join6 } from "path";
 var SERVICE5 = "factory";
@@ -1221,17 +1893,6 @@ function textOf4(content) {
     (content ?? []).filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("")
   );
 }
-function parseLines4(raw) {
-  const out = [];
-  for (const line of raw.split("\n")) {
-    if (!line) continue;
-    try {
-      out.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return out;
-}
 var FactoryAdapter = class {
   harness = "factory";
   aliases = ["factory-droids", "droid"];
@@ -1242,18 +1903,20 @@ var FactoryAdapter = class {
     const root = this.root();
     let dirs;
     try {
-      dirs = await readdir5(root);
-    } catch {
-      return [];
+      dirs = await readdir6(root);
+    } catch (error) {
+      if (isMissingPathError(error)) return [];
+      throw error;
     }
     const refs = [];
     for (const dir of dirs) {
       const dp = join6(root, dir);
       let files;
       try {
-        files = await readdir5(dp);
-      } catch {
-        continue;
+        files = await readdir6(dp);
+      } catch (error) {
+        if (isMissingPathError(error)) continue;
+        throw error;
       }
       const cwd = dir.replace(/-/g, "/");
       if (opts.cwd && !cwd.startsWith(opts.cwd)) continue;
@@ -1263,8 +1926,9 @@ var FactoryAdapter = class {
         let st;
         try {
           st = await stat5(path);
-        } catch {
-          continue;
+        } catch (error) {
+          if (isMissingPathError(error)) continue;
+          throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
         refs.push({ harness: this.harness, sessionId: basename4(f, ".jsonl"), path, cwd, mtimeMs: st.mtimeMs });
@@ -1272,38 +1936,32 @@ var FactoryAdapter = class {
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   }
-  async parse(ref) {
-    const lines = parseLines4(await readFile6(ref.path, "utf8"));
-    const start = lines.find((l) => l.type === "session_start");
-    const traceId = start?.id ?? ref.sessionId;
-    const rootId = `root:${traceId}`;
+  async parse(ref, options = {}) {
     let settings = {};
     try {
-      settings = JSON.parse(await readFile6(ref.path.replace(/\.jsonl$/, ".settings.json"), "utf8"));
-    } catch {
+      settings = await readJsonFile(ref.path.replace(/\.jsonl$/, ".settings.json"));
+    } catch (error) {
+      if (!isMissingJsonSource(error)) throw error;
     }
-    const spans = [
-      span({
-        traceId,
-        spanId: rootId,
-        parentSpanId: null,
-        name: "session",
-        kind: "AGENT",
-        startTime: start?.timestamp ?? lines[0]?.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-        endTime: lines.at(-1)?.timestamp,
-        service: SERVICE5,
-        agent: SERVICE5,
-        model: settings.model ?? null,
-        extra: settings.tokenUsage ? {
-          "session.input_tokens": settings.tokenUsage.inputTokens ?? 0,
-          "session.output_tokens": settings.tokenUsage.outputTokens ?? 0
-        } : void 0
-      })
-    ];
+    const sourceTraceId = ref.sessionId;
+    const sourceRootId = `root:${sourceTraceId}`;
+    const spans = [];
     const toolByUseId = /* @__PURE__ */ new Map();
+    let firstTimestamp;
+    let lastTimestamp;
+    let sessionLine;
+    let sawLine = false;
     let step = 0;
-    let lastLlm = rootId;
-    for (const l of lines) {
+    let lastLlm = sourceRootId;
+    for await (const l of readJsonl(ref.path, sessionJsonlOptions(ref, options))) {
+      if (!sawLine) {
+        firstTimestamp = l.timestamp;
+        sawLine = true;
+      }
+      lastTimestamp = l.timestamp;
+      if (!sessionLine && l.type === "session_start") {
+        sessionLine = { id: l.id, timestamp: l.timestamp };
+      }
       if (l.type !== "message" || !l.message) continue;
       const ts = l.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
       const role = l.message.role;
@@ -1312,9 +1970,9 @@ var FactoryAdapter = class {
         if (text) {
           spans.push(
             userPromptSpan({
-              traceId,
+              traceId: sourceTraceId,
               spanId: `user:${l.id ?? step}`,
-              parentSpanId: rootId,
+              parentSpanId: sourceRootId,
               startTime: ts,
               content: text,
               service: SERVICE5,
@@ -1328,9 +1986,9 @@ var FactoryAdapter = class {
         const llmId = `llm:${l.id ?? step}`;
         spans.push(
           span({
-            traceId,
+            traceId: sourceTraceId,
             spanId: llmId,
-            parentSpanId: rootId,
+            parentSpanId: sourceRootId,
             name: `message.${role ?? "unknown"}`,
             kind: "LLM",
             startTime: ts,
@@ -1347,7 +2005,7 @@ var FactoryAdapter = class {
       for (const b of l.message.content ?? []) {
         if (b.type === "tool_use" && b.name) {
           const t = span({
-            traceId,
+            traceId: sourceTraceId,
             spanId: `tool:${b.id ?? `${l.id}:${step}`}`,
             parentSpanId: lastLlm,
             name: `tool.${b.name}`,
@@ -1357,23 +2015,48 @@ var FactoryAdapter = class {
             agent: SERVICE5,
             tool: b.name,
             step,
-            content: b.input != null ? JSON.stringify(b.input) : null
+            extra: toolIoAttributes({ input: b.input })
           });
           spans.push(t);
           if (b.id) toolByUseId.set(b.id, t);
           step += 1;
         } else if (b.type === "tool_result" && b.tool_use_id) {
           const t = toolByUseId.get(b.tool_use_id);
-          if (t) t.status = b.is_error === true ? { code: "ERROR", message: "tool reported error" } : { code: "OK" };
+          if (t) {
+            t.status = b.is_error === true ? { code: "ERROR", message: "tool reported error" } : { code: "OK" };
+            recordToolOutput(t, b.content);
+          }
         }
       }
     }
-    return spans;
+    const traceId = sessionLine?.id ?? sourceTraceId;
+    const rootId = `root:${traceId}`;
+    for (const item of spans) {
+      item.trace_id = traceId;
+      if (item.parent_span_id === sourceRootId) item.parent_span_id = rootId;
+    }
+    const root = span({
+      traceId,
+      spanId: rootId,
+      parentSpanId: null,
+      name: "session",
+      kind: "AGENT",
+      startTime: sessionLine?.timestamp ?? firstTimestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      endTime: lastTimestamp,
+      service: SERVICE5,
+      agent: SERVICE5,
+      model: settings.model ?? null,
+      extra: settings.tokenUsage ? {
+        "session.input_tokens": settings.tokenUsage.inputTokens ?? 0,
+        "session.output_tokens": settings.tokenUsage.outputTokens ?? 0
+      } : void 0
+    });
+    return [root, ...spans];
   }
 };
 
 // src/adapters/forge.ts
-import { readdir as readdir6, readFile as readFile7, stat as stat6 } from "fs/promises";
+import { readdir as readdir7, stat as stat6 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { basename as basename5, join as join7 } from "path";
 var SERVICE6 = "forge";
@@ -1397,9 +2080,10 @@ var ForgeAdapter = class {
     for (const dir of dirs) {
       let files;
       try {
-        files = await readdir6(dir);
-      } catch {
-        continue;
+        files = await readdir7(dir);
+      } catch (error) {
+        if (isMissingPathError(error)) continue;
+        throw error;
       }
       for (const f of files) {
         if (!f.endsWith("-dump.json")) continue;
@@ -1407,8 +2091,9 @@ var ForgeAdapter = class {
         let st;
         try {
           st = await stat6(path);
-        } catch {
-          continue;
+        } catch (error) {
+          if (isMissingPathError(error)) continue;
+          throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
         refs.push({ harness: this.harness, sessionId: basename5(f, ".json"), path, cwd: dir, mtimeMs: st.mtimeMs });
@@ -1417,12 +2102,7 @@ var ForgeAdapter = class {
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   }
   async parse(ref) {
-    let dump;
-    try {
-      dump = JSON.parse(await readFile7(ref.path, "utf8"));
-    } catch {
-      return [];
-    }
+    const dump = await readJsonFile(ref.path);
     const ctx = dump.context ?? dump;
     const traceId = ctx.conversation_id ?? ref.sessionId;
     const rootId = `root:${traceId}`;
@@ -1487,7 +2167,7 @@ var ForgeAdapter = class {
             agent: SERVICE6,
             tool: tc.name ?? "tool",
             step,
-            content: tc.arguments != null ? JSON.stringify(tc.arguments) : null
+            extra: toolIoAttributes({ input: tc.arguments })
           });
           spans.push(t);
           toolByCallId.set(id, t);
@@ -1495,7 +2175,10 @@ var ForgeAdapter = class {
         }
       } else if (entry.tool) {
         const t = toolByCallId.get(entry.tool.call_id ?? "");
-        if (t) t.status = entry.tool.output?.is_error ? { code: "ERROR", message: "tool reported error" } : { code: "OK" };
+        if (t) {
+          t.status = entry.tool.output?.is_error ? { code: "ERROR", message: "tool reported error" } : { code: "OK" };
+          recordToolOutput(t, entry.tool.output?.values ?? entry.tool.output);
+        }
       }
     }
     return spans;
@@ -1503,7 +2186,7 @@ var ForgeAdapter = class {
 };
 
 // src/adapters/gemini.ts
-import { readdir as readdir7, readFile as readFile8, stat as stat7 } from "fs/promises";
+import { readdir as readdir8, stat as stat7 } from "fs/promises";
 import { homedir as homedir7 } from "os";
 import { join as join8 } from "path";
 function iso(ts, fallback) {
@@ -1539,10 +2222,12 @@ var GeminiFamilyAdapter = class {
   async loadProjectCwds() {
     const nameToPath = /* @__PURE__ */ new Map();
     try {
-      const raw = await readFile8(join8(homedir7(), this.homeDirName, "projects.json"), "utf8");
-      const projects = JSON.parse(raw).projects ?? {};
+      const projects = (await readJsonFile(
+        join8(homedir7(), this.homeDirName, "projects.json")
+      )).projects ?? {};
       for (const [path, name] of Object.entries(projects)) nameToPath.set(name, path);
-    } catch {
+    } catch (error) {
+      if (!isMissingJsonSource(error)) throw error;
     }
     return nameToPath;
   }
@@ -1550,9 +2235,10 @@ var GeminiFamilyAdapter = class {
     const root = this.chatsRoot();
     let projectDirs;
     try {
-      projectDirs = await readdir7(root);
-    } catch {
-      return [];
+      projectDirs = await readdir8(root);
+    } catch (error) {
+      if (isMissingPathError(error)) return [];
+      throw error;
     }
     const projectCwds = await this.loadProjectCwds();
     const refs = [];
@@ -1561,9 +2247,10 @@ var GeminiFamilyAdapter = class {
       const chatsDir = join8(root, pd, "chats");
       let files;
       try {
-        files = await readdir7(chatsDir);
-      } catch {
-        continue;
+        files = await readdir8(chatsDir);
+      } catch (error) {
+        if (isMissingPathError(error)) continue;
+        throw error;
       }
       for (const f of files) {
         if (!f.startsWith("session-") || !f.endsWith(".json")) continue;
@@ -1571,8 +2258,9 @@ var GeminiFamilyAdapter = class {
         let st;
         try {
           st = await stat7(path);
-        } catch {
-          continue;
+        } catch (error) {
+          if (isMissingPathError(error)) continue;
+          throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
         if (opts.cwd && (!cwd || !cwd.startsWith(opts.cwd))) continue;
@@ -1582,12 +2270,7 @@ var GeminiFamilyAdapter = class {
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   }
   async parse(ref) {
-    let session;
-    try {
-      session = JSON.parse(await readFile8(ref.path, "utf8"));
-    } catch {
-      return [];
-    }
+    const session = await readJsonFile(ref.path);
     const traceId = session.sessionId ?? ref.sessionId;
     const messages = session.messages ?? [];
     const rootId = `root:${traceId}`;
@@ -1662,7 +2345,7 @@ var GeminiFamilyAdapter = class {
             agent: this.service,
             tool: tc.name ?? "tool",
             step,
-            content: tc.args != null ? JSON.stringify(tc.args) : null
+            extra: toolIoAttributes({ input: tc.args, output: tc.result })
           })
         );
         step += 1;
@@ -1678,7 +2361,7 @@ var GeminiAdapter = class extends GeminiFamilyAdapter {
 };
 
 // src/adapters/opencode.ts
-import { readdir as readdir8, readFile as readFile9, stat as stat8 } from "fs/promises";
+import { readdir as readdir9, stat as stat8 } from "fs/promises";
 import { homedir as homedir8 } from "os";
 import { join as join9 } from "path";
 var SERVICE7 = "opencode";
@@ -1700,9 +2383,10 @@ var OpencodeAdapter = class {
     const msgRoot = join9(this.storage(), "message");
     let sessionDirs;
     try {
-      sessionDirs = await readdir8(msgRoot);
-    } catch {
-      return [];
+      sessionDirs = await readdir9(msgRoot);
+    } catch (error) {
+      if (isMissingPathError(error)) return [];
+      throw error;
     }
     const refs = [];
     for (const sid of sessionDirs) {
@@ -1710,8 +2394,9 @@ var OpencodeAdapter = class {
       let st;
       try {
         st = await stat8(dir);
-      } catch {
-        continue;
+      } catch (error) {
+        if (isMissingPathError(error)) continue;
+        throw error;
       }
       if (!st.isDirectory()) continue;
       if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
@@ -1724,20 +2409,12 @@ var OpencodeAdapter = class {
     const traceId = ref.sessionId;
     const rootId = `root:${traceId}`;
     const partRoot = join9(this.storage(), "part");
-    let msgFiles;
-    try {
-      msgFiles = (await readdir8(ref.path)).filter((f) => f.endsWith(".json"));
-    } catch {
-      return [];
-    }
+    const msgFiles = await listJsonFiles(ref.path);
     const messages = [];
     for (const f of msgFiles) {
-      try {
-        messages.push({ msg: JSON.parse(await readFile9(join9(ref.path, f), "utf8")), file: f });
-      } catch {
-      }
+      messages.push(await readJsonFile(join9(ref.path, f)));
     }
-    messages.sort((a, b) => (a.msg.time?.created ?? 0) - (b.msg.time?.created ?? 0));
+    messages.sort((a, b) => (a.time?.created ?? 0) - (b.time?.created ?? 0));
     const spans = [
       span({
         traceId,
@@ -1745,59 +2422,65 @@ var OpencodeAdapter = class {
         parentSpanId: null,
         name: "session",
         kind: "AGENT",
-        startTime: isoOf(messages[0]?.msg.time?.created),
-        endTime: isoOf(messages.at(-1)?.msg.time?.completed ?? messages.at(-1)?.msg.time?.created),
+        startTime: isoOf(messages[0]?.time?.created),
+        endTime: isoOf(messages.at(-1)?.time?.completed ?? messages.at(-1)?.time?.created),
         service: SERVICE7,
         agent: SERVICE7
       })
     ];
     let step = 0;
-    for (const { msg } of messages) {
+    for (const msg of messages) {
       const mid = msg.id ?? `m${step}`;
       const llmId = `llm:${mid}`;
       const pdir = join9(partRoot, mid);
       const parts = [];
+      let partFiles = [];
       try {
-        const partFiles = (await readdir8(pdir)).filter((f) => f.endsWith(".json"));
-        for (const pf of partFiles) {
-          try {
-            parts.push(JSON.parse(await readFile9(join9(pdir, pf), "utf8")));
-          } catch {
-          }
-        }
-      } catch {
+        partFiles = await listJsonFiles(pdir);
+      } catch (error) {
+        if (!isMissingJsonSource(error)) throw error;
+      }
+      for (const pf of partFiles) {
+        parts.push(await readJsonFile(join9(pdir, pf)));
       }
       const turnText = textOf7(parts);
-      spans.push(
-        span({
-          traceId,
-          spanId: llmId,
-          parentSpanId: rootId,
-          name: `message.${msg.role ?? "unknown"}`,
-          kind: "LLM",
-          startTime: isoOf(msg.time?.created),
-          endTime: isoOf(msg.time?.completed ?? msg.time?.created),
-          service: SERVICE7,
-          agent: SERVICE7,
-          model: msg.modelID ?? null,
-          inputTokens: msg.tokens?.input ?? null,
-          outputTokens: msg.tokens?.output ?? null,
-          step,
-          content: turnText || null
-        })
-      );
-      step += 1;
-      if (msg.role === "user" && turnText) {
+      const isUser = msg.role === "user";
+      if (isUser) {
+        if (turnText) {
+          spans.push(
+            userPromptSpan({
+              traceId,
+              spanId: `${llmId}:user`,
+              parentSpanId: rootId,
+              startTime: isoOf(msg.time?.created),
+              service: SERVICE7,
+              agent: SERVICE7,
+              step,
+              content: turnText
+            })
+          );
+          step += 1;
+        }
+      } else {
         spans.push(
-          userPromptSpan({
+          span({
             traceId,
-            spanId: `${llmId}:user`,
+            spanId: llmId,
             parentSpanId: rootId,
+            name: `message.${msg.role ?? "unknown"}`,
+            kind: "LLM",
             startTime: isoOf(msg.time?.created),
+            endTime: isoOf(msg.time?.completed ?? msg.time?.created),
             service: SERVICE7,
             agent: SERVICE7,
+            model: msg.modelID ?? null,
+            inputTokens: msg.tokens?.input ?? null,
+            outputTokens: msg.tokens?.output ?? null,
+            reasoningTokens: msg.tokens?.reasoning ?? null,
+            cachedInputTokens: msg.tokens?.cache?.read ?? null,
+            cacheWriteInputTokens: msg.tokens?.cache?.write ?? null,
             step,
-            content: turnText
+            content: turnText || null
           })
         );
         step += 1;
@@ -1809,7 +2492,7 @@ var OpencodeAdapter = class {
           span({
             traceId,
             spanId: `tool:${part.callID ?? `${mid}:${step}`}`,
-            parentSpanId: llmId,
+            parentSpanId: isUser ? rootId : llmId,
             name: `tool.${part.tool}`,
             kind: "TOOL",
             startTime: isoOf(msg.time?.created),
@@ -1820,7 +2503,10 @@ var OpencodeAdapter = class {
             agent: SERVICE7,
             tool: part.tool,
             step,
-            content: part.state?.input != null ? JSON.stringify(part.state.input) : null
+            extra: toolIoAttributes({
+              input: part.state?.input,
+              output: part.state?.output ?? part.state?.error
+            })
           })
         );
         step += 1;
@@ -1831,21 +2517,10 @@ var OpencodeAdapter = class {
 };
 
 // src/adapters/pi.ts
-import { readdir as readdir9, readFile as readFile10, stat as stat9 } from "fs/promises";
+import { readdir as readdir10, stat as stat9 } from "fs/promises";
 import { homedir as homedir9 } from "os";
 import { basename as basename6, join as join10 } from "path";
 var SERVICE8 = "pi";
-function parseLines5(raw) {
-  const out = [];
-  for (const line of raw.split("\n")) {
-    if (!line) continue;
-    try {
-      out.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return out;
-}
 function isToolBlock(b) {
   return typeof b.type === "string" && /tool[_-]?call|tool[_-]?use|^tool$/i.test(b.type);
 }
@@ -1867,18 +2542,20 @@ var PiAdapter = class {
     const root = this.root();
     let dirs;
     try {
-      dirs = await readdir9(root);
-    } catch {
-      return [];
+      dirs = await readdir10(root);
+    } catch (error) {
+      if (isMissingPathError(error)) return [];
+      throw error;
     }
     const refs = [];
     for (const dir of dirs) {
       const dp = join10(root, dir);
       let files;
       try {
-        files = await readdir9(dp);
-      } catch {
-        continue;
+        files = await readdir10(dp);
+      } catch (error) {
+        if (isMissingPathError(error)) continue;
+        throw error;
       }
       const cwd = `/${dir.replace(/^-+/, "").replace(/-+$/, "").replace(/-/g, "/")}`;
       if (opts.cwd && !cwd.startsWith(opts.cwd)) continue;
@@ -1888,8 +2565,9 @@ var PiAdapter = class {
         let st;
         try {
           st = await stat9(path);
-        } catch {
-          continue;
+        } catch (error) {
+          if (isMissingPathError(error)) continue;
+          throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
         const id = basename6(f, ".jsonl").replace(/^[\dTZ.-]+_/, "");
@@ -1898,27 +2576,25 @@ var PiAdapter = class {
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   }
-  async parse(ref) {
-    const lines = parseLines5(await readFile10(ref.path, "utf8"));
-    const sessionLine = lines.find((l) => l.type === "session");
-    const traceId = sessionLine?.id ?? ref.sessionId;
-    const rootId = `root:${traceId}`;
-    const spans = [
-      span({
-        traceId,
-        spanId: rootId,
-        parentSpanId: null,
-        name: "session",
-        kind: "AGENT",
-        startTime: sessionLine?.timestamp ?? lines[0]?.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-        endTime: lines.at(-1)?.timestamp,
-        service: SERVICE8,
-        agent: SERVICE8
-      })
-    ];
+  async parse(ref, options = {}) {
+    const sourceTraceId = ref.sessionId;
+    const sourceRootId = `root:${sourceTraceId}`;
+    const spans = [];
     const toolByCallId = /* @__PURE__ */ new Map();
+    let firstTimestamp;
+    let lastTimestamp;
+    let sessionLine;
+    let sawLine = false;
     let step = 0;
-    for (const l of lines) {
+    for await (const l of readJsonl(ref.path, sessionJsonlOptions(ref, options))) {
+      if (!sawLine) {
+        firstTimestamp = l.timestamp;
+        sawLine = true;
+      }
+      lastTimestamp = l.timestamp;
+      if (!sessionLine && l.type === "session") {
+        sessionLine = { id: l.id, timestamp: l.timestamp };
+      }
       if (l.type !== "message" || !l.message) continue;
       const ts = l.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
       const mid = l.id ?? `m${step}`;
@@ -1929,9 +2605,9 @@ var PiAdapter = class {
         if (prompt) {
           spans.push(
             userPromptSpan({
-              traceId,
+              traceId: sourceTraceId,
               spanId: `${mid}:user`,
-              parentSpanId: rootId,
+              parentSpanId: sourceRootId,
               startTime: ts,
               service: SERVICE8,
               agent: SERVICE8,
@@ -1945,9 +2621,9 @@ var PiAdapter = class {
         const errored = !!msg.errorMessage;
         spans.push(
           span({
-            traceId,
+            traceId: sourceTraceId,
             spanId: llmId,
-            parentSpanId: rootId,
+            parentSpanId: sourceRootId,
             name: `message.${msg.role ?? "unknown"}`,
             kind: "LLM",
             startTime: ts,
@@ -1969,7 +2645,7 @@ var PiAdapter = class {
           const name = b.toolName ?? b.name ?? "tool";
           const callId = b.id ?? b.callId ?? b.toolCallId ?? `${mid}:${step}`;
           const toolSpan = span({
-            traceId,
+            traceId: sourceTraceId,
             spanId: `tool:${callId}`,
             parentSpanId: llmId,
             name: `tool.${name}`,
@@ -1979,7 +2655,7 @@ var PiAdapter = class {
             agent: SERVICE8,
             tool: name,
             step,
-            content: (b.input ?? b.args) != null ? JSON.stringify(b.input ?? b.args) : null
+            extra: toolIoAttributes({ input: b.input ?? b.args })
           });
           spans.push(toolSpan);
           toolByCallId.set(callId, toolSpan);
@@ -1991,30 +2667,37 @@ var PiAdapter = class {
             const err = b.isError === true || b.is_error === true;
             t.end_time = ts;
             t.status = err ? { code: "ERROR", message: "tool result reported error" } : { code: "OK" };
+            recordToolOutput(t, b.output ?? b.result ?? b.content ?? b.text);
           }
         }
       }
     }
-    return spans;
+    const traceId = sessionLine?.id ?? sourceTraceId;
+    const rootId = `root:${traceId}`;
+    for (const item of spans) {
+      item.trace_id = traceId;
+      if (item.parent_span_id === sourceRootId) item.parent_span_id = rootId;
+    }
+    const root = span({
+      traceId,
+      spanId: rootId,
+      parentSpanId: null,
+      name: "session",
+      kind: "AGENT",
+      startTime: sessionLine?.timestamp ?? firstTimestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      endTime: lastTimestamp,
+      service: SERVICE8,
+      agent: SERVICE8
+    });
+    return [root, ...spans];
   }
 };
 
 // src/adapters/qwen.ts
-import { readdir as readdir10, readFile as readFile11, stat as stat10 } from "fs/promises";
+import { readdir as readdir11, stat as stat10 } from "fs/promises";
 import { homedir as homedir10 } from "os";
 import { basename as basename7, join as join11 } from "path";
 var SERVICE9 = "qwen";
-function parseLines6(raw) {
-  const out = [];
-  for (const line of raw.split("\n")) {
-    if (!line) continue;
-    try {
-      out.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return out;
-}
 function textOf9(parts) {
   if (!parts) return "";
   return parts.filter((p) => typeof p.text === "string").map((p) => p.text).join("");
@@ -2029,18 +2712,20 @@ var QwenAdapter = class {
     const root = this.root();
     let projectDirs;
     try {
-      projectDirs = await readdir10(root);
-    } catch {
-      return [];
+      projectDirs = await readdir11(root);
+    } catch (error) {
+      if (isMissingPathError(error)) return [];
+      throw error;
     }
     const refs = [];
     for (const pd of projectDirs) {
       const chatsDir = join11(root, pd, "chats");
       let files;
       try {
-        files = await readdir10(chatsDir);
-      } catch {
-        continue;
+        files = await readdir11(chatsDir);
+      } catch (error) {
+        if (isMissingPathError(error)) continue;
+        throw error;
       }
       if (opts.cwd) continue;
       for (const f of files) {
@@ -2049,8 +2734,9 @@ var QwenAdapter = class {
         let st;
         try {
           st = await stat10(path);
-        } catch {
-          continue;
+        } catch (error) {
+          if (isMissingPathError(error)) continue;
+          throw error;
         }
         if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
         refs.push({ harness: this.harness, sessionId: basename7(f, ".jsonl"), path, cwd: null, mtimeMs: st.mtimeMs });
@@ -2058,36 +2744,32 @@ var QwenAdapter = class {
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   }
-  async parse(ref) {
-    const records = parseLines6(await readFile11(ref.path, "utf8"));
-    const traceId = records.find((r) => r.sessionId)?.sessionId ?? ref.sessionId;
-    const rootId = `root:${traceId}`;
-    const spans = [
-      span({
-        traceId,
-        spanId: rootId,
-        parentSpanId: null,
-        name: "session",
-        kind: "AGENT",
-        startTime: records[0]?.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-        endTime: records.at(-1)?.timestamp,
-        service: SERVICE9,
-        agent: SERVICE9
-      })
-    ];
+  async parse(ref, options = {}) {
+    const sourceTraceId = ref.sessionId;
+    const sourceRootId = `root:${sourceTraceId}`;
+    const spans = [];
     const openToolsByName = /* @__PURE__ */ new Map();
+    let discoveredTraceId;
+    let firstTimestamp;
+    let lastTimestamp;
+    let sawRecord = false;
     let step = 0;
-    let lastLlm = rootId;
-    for (const r of records) {
+    for await (const r of readJsonl(ref.path, sessionJsonlOptions(ref, options))) {
+      if (!sawRecord) {
+        firstTimestamp = r.timestamp;
+        sawRecord = true;
+      }
+      lastTimestamp = r.timestamp;
+      if (!discoveredTraceId && r.sessionId) discoveredTraceId = r.sessionId;
       const ts = r.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
       const role = r.message?.role;
       if (r.type === "assistant" || role === "model") {
         const llmId = `llm:${r.uuid ?? step}`;
         spans.push(
           span({
-            traceId,
+            traceId: sourceTraceId,
             spanId: llmId,
-            parentSpanId: rootId,
+            parentSpanId: sourceRootId,
             name: "llm.turn",
             kind: "LLM",
             startTime: ts,
@@ -2100,13 +2782,12 @@ var QwenAdapter = class {
             content: capText(textOf9(r.message?.parts)) || null
           })
         );
-        lastLlm = llmId;
         step += 1;
         for (const p of r.message?.parts ?? []) {
           if (!p.functionCall?.name) continue;
           const name = p.functionCall.name;
           const t = span({
-            traceId,
+            traceId: sourceTraceId,
             spanId: `tool:${name}:${step}`,
             parentSpanId: llmId,
             name: `tool.${name}`,
@@ -2116,7 +2797,7 @@ var QwenAdapter = class {
             agent: SERVICE9,
             tool: name,
             step,
-            content: p.functionCall.args != null ? JSON.stringify(p.functionCall.args) : null
+            extra: toolIoAttributes({ input: p.functionCall.args })
           });
           spans.push(t);
           const q = openToolsByName.get(name) ?? [];
@@ -2129,9 +2810,9 @@ var QwenAdapter = class {
         if (prompt) {
           spans.push(
             userPromptSpan({
-              traceId,
+              traceId: sourceTraceId,
               spanId: `user:${r.uuid ?? step}`,
-              parentSpanId: rootId,
+              parentSpanId: sourceRootId,
               startTime: ts,
               service: SERVICE9,
               agent: SERVICE9,
@@ -2150,11 +2831,29 @@ var QwenAdapter = class {
           if (t) {
             t.end_time = ts;
             t.status = err ? { code: "ERROR", message: "tool result reported error" } : { code: "OK" };
+            recordToolOutput(t, p.functionResponse?.response ?? r.toolCallResult?.error);
           }
         }
       }
     }
-    return spans;
+    const traceId = discoveredTraceId ?? sourceTraceId;
+    const rootId = `root:${traceId}`;
+    for (const item of spans) {
+      item.trace_id = traceId;
+      if (item.parent_span_id === sourceRootId) item.parent_span_id = rootId;
+    }
+    const root = span({
+      traceId,
+      spanId: rootId,
+      parentSpanId: null,
+      name: "session",
+      kind: "AGENT",
+      startTime: firstTimestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      endTime: lastTimestamp,
+      service: SERVICE9,
+      agent: SERVICE9
+    });
+    return [root, ...spans];
   }
 };
 
@@ -2554,14 +3253,25 @@ async function stampSpanWorkdirRepoAttrs(spans) {
 }
 
 // src/session-source.ts
-async function parseSession(adapter, ref) {
-  const spans = await adapter.parse(ref);
+async function parseSession(adapter, ref, options = {}) {
+  const spans = await adapter.parse(ref, options);
+  if (spans.length === 0) throw new EmptySessionError(ref.path);
+  stampSessionIntegrity(ref, spans);
+  stampSessionIdentity(spans, ref.sessionId);
   const repo = await resolveSessionRepoAttrs(ref.cwd, spans);
   if (repo.cwd) ref.cwd = repo.cwd;
   stampRepoAttrs(spans, repo.attrs);
   await stampSpanWorkdirRepoAttrs(spans);
   return spans;
 }
+var EmptySessionError = class extends Error {
+  sourcePath;
+  constructor(sourcePath) {
+    super(`Session parser produced no spans at ${sourcePath}`);
+    this.name = "EmptySessionError";
+    this.sourcePath = sourcePath;
+  }
+};
 function refKey(ref) {
   return `${ref.harness}\0${ref.path}\0${ref.sessionId}`;
 }
@@ -2571,7 +3281,7 @@ async function locateSessions(adapter, opts = {}) {
   const refs = await adapter.locate({ sinceMs: opts.sinceMs });
   const byKey = /* @__PURE__ */ new Map();
   for (const ref of refs) {
-    if (!cwdMatchesSelection(ref.cwd, cwdSelections)) continue;
+    if (!cwdMatchesSelection(ref.cwd, cwdSelections) && !(ref.cwd === null && ref.integrity)) continue;
     byKey.set(refKey(ref), ref);
   }
   return [...byKey.values()].sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -2583,7 +3293,8 @@ async function* scanSessions(opts) {
     try {
       refs = await locateSessions(adapter, { cwd: opts.cwd, sinceMs: opts.sinceMs });
     } catch (err) {
-      opts.onError?.(err);
+      if (!opts.onError) throw err;
+      opts.onError(err);
       continue;
     }
     if (opts.last && opts.last > 0) refs = refs.slice(0, opts.last);
@@ -2591,12 +3302,12 @@ async function* scanSessions(opts) {
       if (opts.signal?.aborted) return;
       let spans;
       try {
-        spans = await parseSession(adapter, ref);
+        spans = await parseSession(adapter, ref, { corruptionMode: opts.corruptionMode });
       } catch (err) {
-        opts.onError?.(err, ref);
+        if (!opts.onError) throw err;
+        opts.onError(err, ref);
         continue;
       }
-      if (spans.length === 0) continue;
       yield { adapter, ref, spans };
     }
   }
@@ -2606,16 +3317,16 @@ async function* scanSessions(opts) {
 import { mkdtemp, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join as join13 } from "path";
+import {
+  OPENINFERENCE_SPAN_KIND as OPENINFERENCE_SPAN_KIND2,
+  TOOL_NAME as TOOL_NAME2
+} from "@tangle-network/agent-eval/trace-attributes";
 function stringAttr(span2, key) {
   const value = span2.attributes[key];
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function numberAttr(span2, key) {
-  const value = span2.attributes[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
 function spanKind(span2) {
-  return stringAttr(span2, "openinference.span.kind");
+  return stringAttr(span2, OPENINFERENCE_SPAN_KIND2);
 }
 function repoFromSpans(spans) {
   const attrs = {};
@@ -2641,7 +3352,7 @@ function summarizeTools(spans) {
   const byTool = /* @__PURE__ */ new Map();
   for (const span2 of spans) {
     if (spanKind(span2) !== "TOOL") continue;
-    const name = stringAttr(span2, "tool.name") ?? span2.name.replace(/^tool\./, "");
+    const name = stringAttr(span2, TOOL_NAME2) ?? span2.name.replace(/^tool\./, "");
     const current = byTool.get(name) ?? { calls: 0, errors: 0 };
     current.calls += 1;
     if (span2.status.code === "ERROR") current.errors += 1;
@@ -2650,7 +3361,6 @@ function summarizeTools(spans) {
   return [...byTool.entries()].map(([name, row]) => ({ name, calls: row.calls, errors: row.errors })).sort((a, b) => b.calls - a.calls || a.name.localeCompare(b.name));
 }
 async function buildPolicyEvidenceRecord(ref, spans, opts = {}) {
-  const llmSpans = spans.filter((span2) => spanKind(span2) === "LLM");
   const toolSpans = spans.filter((span2) => spanKind(span2) === "TOOL");
   const erroredToolCallCount = toolSpans.filter((span2) => span2.status.code === "ERROR").length;
   const pipelines = await runPipelines(spans, { minLoopOccurrences: opts.minLoopOccurrences });
@@ -2658,10 +3368,14 @@ async function buildPolicyEvidenceRecord(ref, spans, opts = {}) {
   const loopFindings = pipelines.stuckLoops.findings;
   const { firstSpanAt, lastSpanAt } = timeBounds(spans);
   const repo = repoFromSpans(spans);
+  const execution = summarizeSpanExecution(spans, {
+    experimentId: `traces-policy-evidence:${ref.sessionId}`
+  });
   return {
     schemaVersion: 1,
     kind: "traces.policy_evidence.session",
     generatedAt: opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    execution,
     session: {
       harness: ref.harness,
       sessionId: ref.sessionId,
@@ -2672,12 +3386,12 @@ async function buildPolicyEvidenceRecord(ref, spans, opts = {}) {
     repo,
     metrics: {
       spanCount: spans.length,
-      llmTurnCount: llmSpans.length,
+      llmTurnCount: execution.execution.modelCalls.events,
       toolCallCount: toolSpans.length,
       erroredToolCallCount,
-      inputTokens: llmSpans.reduce((sum, span2) => sum + numberAttr(span2, "llm.input_tokens"), 0),
-      outputTokens: llmSpans.reduce((sum, span2) => sum + numberAttr(span2, "llm.output_tokens"), 0),
-      models: [...new Set(llmSpans.map((span2) => stringAttr(span2, "llm.model_name")).filter((value) => Boolean(value)))].sort(),
+      inputTokens: execution.execution.tokenUsage.totals.input,
+      outputTokens: execution.execution.tokenUsage.totals.output,
+      models: execution.execution.models.map(({ model }) => model),
       tools: summarizeTools(spans),
       firstSpanAt,
       lastSpanAt
@@ -2859,6 +3573,7 @@ function redactSpans(spans, rules = TRACES_REDACTION_RULES) {
   const report = { redactionCount: 0, byRule: {} };
   const out = spans.map((s) => {
     const attributes = redactValue(s.attributes, rules, report).value;
+    normalizeToolIoAttributes(attributes);
     let status = s.status;
     if (status.message) {
       const m = redactValue(status.message, rules, report).value;
@@ -2869,33 +3584,66 @@ function redactSpans(spans, rules = TRACES_REDACTION_RULES) {
   return { spans: out, report };
 }
 async function applyRedactor(spans, redactor) {
-  const idx = [];
+  const capturedKeys = ["content", ...TOOL_IO_VALUE_KEYS];
+  const fields = [];
   const texts = [];
   spans.forEach((s, i) => {
-    const c = s.attributes["content"];
-    if (typeof c === "string" && c.length > 0) {
-      idx.push(i);
-      texts.push(c);
+    for (const key of capturedKeys) {
+      const value = s.attributes[key];
+      if (typeof value === "string" && value.length > 0) {
+        fields.push({ spanIndex: i, key });
+        texts.push(value);
+      }
+    }
+    if (s.status.message) {
+      fields.push({ spanIndex: i, key: "status.message" });
+      texts.push(s.status.message);
     }
   });
   const out = spans.map((s) => ({ ...s, attributes: { ...s.attributes } }));
-  if (texts.length === 0) return { spans: out, changed: 0 };
+  if (texts.length === 0) {
+    for (const span2 of out) normalizeToolIoAttributes(span2.attributes);
+    return { spans: out, changed: 0 };
+  }
   const scrubbed = await redactor.redactText(texts);
+  if (scrubbed.length !== texts.length) {
+    throw new Error(`redactor ${redactor.name}: expected ${texts.length} values, received ${scrubbed.length}`);
+  }
   let changed = 0;
-  idx.forEach((spanI, k) => {
+  fields.forEach(({ spanIndex, key }, k) => {
     if (scrubbed[k] !== texts[k]) {
-      out[spanI].attributes["content"] = scrubbed[k];
+      if (key === "status.message") {
+        out[spanIndex].status = { ...out[spanIndex].status, message: scrubbed[k] };
+      } else {
+        out[spanIndex].attributes[key] = scrubbed[k];
+      }
       changed += 1;
     }
   });
+  for (const span2 of out) normalizeToolIoAttributes(span2.attributes);
   return { spans: out, changed };
 }
 
 // src/file-export.ts
-import { createHash } from "crypto";
-import { mkdtemp as mkdtemp2, readFile as readFile12, writeFile as writeFile2 } from "fs/promises";
+import { createHash as createHash4 } from "crypto";
+import { mkdtemp as mkdtemp2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join14 } from "path";
+import {
+  firstNumberAttr,
+  LLM_CACHED_TOKEN_ATTR_KEYS,
+  LLM_CACHED_TOKENS,
+  LLM_CACHE_WRITE_TOKEN_ATTR_KEYS,
+  LLM_CACHE_WRITE_TOKENS,
+  LLM_COST_ATTR_KEYS,
+  LLM_COST_USD,
+  LLM_INPUT_TOKEN_ATTR_KEYS,
+  LLM_INPUT_TOKENS,
+  LLM_OUTPUT_TOKEN_ATTR_KEYS,
+  LLM_OUTPUT_TOKENS,
+  LLM_REASONING_TOKEN_ATTR_KEYS,
+  LLM_REASONING_TOKENS
+} from "@tangle-network/agent-eval/trace-attributes";
 function isObject(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
@@ -2915,7 +3663,7 @@ function stableJson(value) {
   });
 }
 function hashId(value, chars = 16) {
-  return createHash("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
+  return createHash4("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
 }
 function isoTime(value) {
   if (typeof value === "string") {
@@ -3018,6 +3766,11 @@ function requireOpenInferenceRows(rows) {
   return rows;
 }
 function requireIntelligenceSpanRows(rows) {
+  if (rows.length > 0 && rows.every(isOpenInferenceRow)) {
+    throw new Error(
+      "intelligence-spans input is already complete OpenInference; use --format auto or --format openinference to preserve it losslessly"
+    );
+  }
   if (!rows.every(isIntelligenceSpanRow)) throw new Error("intelligence-spans input must contain only Intelligence span rows");
   return rows;
 }
@@ -3049,6 +3802,7 @@ function policyEvidenceToSpans(records) {
       "traces.metrics.errored_tool_call_count": record.metrics.erroredToolCallCount,
       "traces.metrics.input_tokens": record.metrics.inputTokens,
       "traces.metrics.output_tokens": record.metrics.outputTokens,
+      "traces.execution": stableJson(record.execution),
       "traces.metrics.models": record.metrics.models,
       "traces.metrics.tools": stableJson(record.metrics.tools),
       "traces.signals.stuck_loop_count": record.signals.stuckLoopCount,
@@ -3076,6 +3830,11 @@ function policyEvidenceToSpans(records) {
       endTime: end,
       service: record.session.harness,
       agent: "traces",
+      inputTokens: record.execution.execution.tokenUsage.totals.input,
+      outputTokens: record.execution.execution.tokenUsage.totals.output,
+      reasoningTokens: record.execution.execution.tokenUsage.totals.reasoning,
+      cachedInputTokens: record.execution.execution.tokenUsage.totals.cached,
+      cacheWriteInputTokens: record.execution.execution.tokenUsage.totals.cacheWrite,
       content: capText(stableJson({
         session: record.session,
         repo: record.repo,
@@ -3106,6 +3865,16 @@ function findStringKey(value, keys, depth = 4) {
   }
   return void 0;
 }
+function eventValue(row, keys) {
+  const scopes = [row, objectValue(row.data), objectValue(row.payload)];
+  for (const scope of scopes) {
+    if (!scope) continue;
+    for (const key of keys) {
+      if (scope[key] !== void 0) return scope[key];
+    }
+  }
+  return void 0;
+}
 function eventTimestamp(row) {
   return firstTimeDeep(row, [
     "timestamp",
@@ -3148,7 +3917,8 @@ function eventKind(row, type) {
 }
 function sandboxEventsToSpans(rows, wrapper) {
   const context = wrapper ?? {};
-  const traceId = findStringKey(context, ["trace_id", "traceId", "session_id", "sessionId", "run_id", "runId"], 3) ?? findStringKey(rows, ["trace_id", "traceId", "session_id", "sessionId", "run_id", "runId"], 4) ?? `sandbox:${hashId(rows, 32)}`;
+  const sessionId = findStringKey(context, ["session_id", "sessionId"], 3) ?? findStringKey(rows, ["session_id", "sessionId"], 4);
+  const traceId = findStringKey(context, ["trace_id", "traceId"], 3) ?? findStringKey(rows, ["trace_id", "traceId"], 4) ?? sessionId ?? findStringKey(context, ["run_id", "runId"], 3) ?? findStringKey(rows, ["run_id", "runId"], 4) ?? `sandbox:${hashId(rows, 32)}`;
   const service = findStringKey(context, ["service", "harness", "source"], 2) ?? "sandbox-opencode";
   const times = rows.flatMap((row) => {
     const time = eventTimestamp(row);
@@ -3184,10 +3954,16 @@ function sandboxEventsToSpans(rows, wrapper) {
     const { status, message } = eventStatus(row, type);
     const { kind, tool } = eventKind(row, type);
     const name = kind === "TOOL" && tool ? `tool.${tool}` : `event.${type}`;
+    const toolInput = kind === "TOOL" ? eventValue(row, ["toolInput", "tool_input", "input", "args", "arguments", "full_command"]) : void 0;
     const extra = {
       "traces.source_format": "sandbox-events",
       "traces.event.type": type,
-      "traces.event.index": index
+      "traces.event.index": index,
+      ...kind === "TOOL" ? toolIoAttributes({
+        input: toolInput,
+        output: eventValue(row, ["toolOutput", "tool_output", "output", "result"]),
+        argsCaptured: toolInput !== void 0
+      }) : {}
     };
     copyDefined(extra, {
       "traces.event.id": stringValue(row.id),
@@ -3212,7 +3988,11 @@ function sandboxEventsToSpans(rows, wrapper) {
       extra
     }));
   });
-  return spans;
+  if (!sessionId) return spans;
+  return spans.map((item) => ({
+    ...item,
+    attributes: { ...item.attributes, [ATTR.SESSION_ID]: sessionId }
+  }));
 }
 function statusCode(value) {
   return value === "OK" || value === "ERROR" || value === "UNSET" ? value : "UNSET";
@@ -3236,8 +4016,8 @@ function unixNanoTime(value) {
 }
 function firstNumber(row, attrs, keys) {
   for (const key of keys) {
-    const value = numberValue(row[key]) ?? numberValue(attrs[key]);
-    if (value != null) return value;
+    const value = firstNumberAttr(row, [key]) ?? firstNumberAttr(attrs, [key]);
+    if (value !== null) return value;
   }
   return void 0;
 }
@@ -3249,6 +4029,12 @@ var COMPUTED_SPAN_ATTRIBUTES = /* @__PURE__ */ new Set([
   "tool.name",
   "llm.input_tokens",
   "llm.output_tokens",
+  LLM_INPUT_TOKENS,
+  LLM_OUTPUT_TOKENS,
+  LLM_REASONING_TOKENS,
+  LLM_CACHED_TOKENS,
+  LLM_CACHE_WRITE_TOKENS,
+  LLM_COST_USD,
   "step",
   "content"
 ]);
@@ -3263,10 +4049,27 @@ function preserveRawAttributes(attrs) {
   }
   return preserved;
 }
+function capturedToolIo(attrs) {
+  const input = attrs["input.value"] ?? attrs["tool.input"] ?? attrs.tool_input ?? attrs["tool.arguments"] ?? attrs.tool_arguments ?? attrs.arguments ?? attrs.args ?? attrs.full_command;
+  const capture = toolArgumentsFromAttributes({ ...attrs, "input.value": input });
+  return toolIoAttributes({
+    input: capture.args,
+    output: attrs["output.value"] ?? attrs["tool.output"] ?? attrs.tool_output,
+    argsCaptured: capture.argsCaptured
+  });
+}
+function isToolTelemetrySpan(attrs) {
+  const spanType = stringValue(attrs["span.type"])?.toLowerCase();
+  return spanType === "tool.execution" || spanType === "tool.blocked_on_user";
+}
+function otlpSpanKind(value) {
+  return value === "AGENT" || value === "LLM" || value === "TOOL" || value === "CHAIN" || value === "SPAN" ? value : void 0;
+}
 function intelligenceSpanKind(name, attrs) {
   const lowered = name.toLowerCase();
   const spanType = stringValue(attrs["span.type"])?.toLowerCase();
   if (spanType === "llm_request" || lowered.includes("llm")) return "LLM";
+  if (isToolTelemetrySpan(attrs)) return "CHAIN";
   if (spanType === "tool" || lowered.includes("tool") || attrs["tool.name"] != null || attrs.tool_name != null || attrs["mcp.tool.name"] != null || attrs["tool.input"] != null || attrs["tool.output"] != null) {
     return "TOOL";
   }
@@ -3281,9 +4084,12 @@ function intelligenceSpansToSpans(rows) {
     const endTime = unixNanoTime(row.end_unix_nano) ?? isoTime(row.end_time) ?? stringValue(row.end_time) ?? startTime;
     const model = stringValue(row.model) ?? stringValue(attrs["llm.model_name"]) ?? stringValue(attrs.model) ?? stringValue(attrs["gen_ai.request.model"]);
     const tool = stringValue(attrs["tool.name"]) ?? stringValue(attrs.tool_name) ?? stringValue(attrs["mcp.tool.name"]);
-    const sessionId = stringValue(row.session_id) ?? stringValue(attrs["session.id"]);
+    const kind = intelligenceSpanKind(name, attrs);
+    const sourceStatus = objectValue(row.status);
+    const sessionId = stringValue(row.session_id) ?? sessionIdFromAttributes(attrs);
     const extra = {
       ...preserveRawAttributes(attrs),
+      ...kind === "TOOL" ? capturedToolIo(attrs) : {},
       "traces.source_format": "intelligence-spans",
       "traces.row.index": index
     };
@@ -3297,7 +4103,6 @@ function intelligenceSpansToSpans(rows) {
       "generation.id": stringValue(row.generation),
       "cell.id": stringValue(row.cell_id),
       "project.key": stringValue(row.project_key),
-      "llm.cost_usd": numberValue(row.cost_usd),
       "redaction.version": stringValue(row.redaction_version),
       "traces.received_at": isoTime(row.received_at)
     });
@@ -3306,17 +4111,21 @@ function intelligenceSpansToSpans(rows) {
       spanId: stringValue(row.id) ?? hashId({ row, field: "span" }),
       parentSpanId: stringValue(row.parent_span_id) ?? null,
       name,
-      kind: intelligenceSpanKind(name, attrs),
+      kind,
       startTime,
       endTime,
-      status: statusCode(row.status_code),
-      statusMessage: stringValue(row.status_message),
+      status: statusCode(row.status_code ?? sourceStatus?.code),
+      statusMessage: stringValue(row.status_message) ?? stringValue(sourceStatus?.message),
       service: stringValue(attrs["service.name"]) ?? stringValue(attrs.service_name) ?? "tangle-intelligence",
       agent: stringValue(attrs["agent.name"]) ?? stringValue(attrs["service.name"]) ?? null,
       model,
       tool,
-      inputTokens: firstNumber(row, attrs, ["input_tokens", "llm.input_tokens"]),
-      outputTokens: firstNumber(row, attrs, ["output_tokens", "llm.output_tokens"]),
+      inputTokens: firstNumber(row, attrs, ["input_tokens", ...LLM_INPUT_TOKEN_ATTR_KEYS]),
+      outputTokens: firstNumber(row, attrs, ["output_tokens", ...LLM_OUTPUT_TOKEN_ATTR_KEYS]),
+      reasoningTokens: firstNumber(row, attrs, LLM_REASONING_TOKEN_ATTR_KEYS),
+      cachedInputTokens: firstNumber(row, attrs, LLM_CACHED_TOKEN_ATTR_KEYS),
+      cacheWriteInputTokens: firstNumber(row, attrs, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS),
+      costUsd: firstNumber(row, attrs, ["cost_usd", ...LLM_COST_ATTR_KEYS]),
       step: numberValue(attrs["interaction.sequence"]) ?? index,
       content: stringValue(attrs.user_prompt) ?? stringValue(attrs["gen_ai.prompt.messages"]) ?? stringValue(attrs["log.content.task"]) ?? null,
       extra
@@ -3329,15 +4138,21 @@ function openInferenceToSpans(rows) {
     const resource = objectValue(row.resource);
     const resourceAttrs = objectValue(resource?.attributes);
     if (resourceAttrs) copyDefined(attrs, resourceAttrs);
-    const kind = stringValue(row.kind);
-    if (kind && attrs["openinference.span.kind"] == null) attrs["openinference.span.kind"] = kind;
+    const name = stringValue(row.name) ?? "span";
+    const declaredKind = otlpSpanKind(attrs["openinference.span.kind"]) ?? otlpSpanKind(row.kind);
+    const kind = isToolTelemetrySpan(attrs) ? "CHAIN" : declaredKind ?? intelligenceSpanKind(name, attrs);
+    if (declaredKind && declaredKind !== kind) {
+      attrs["traces.raw_attribute.openinference.span.kind"] = declaredKind;
+    }
+    attrs["openinference.span.kind"] = kind;
+    if (kind === "TOOL") Object.assign(attrs, capturedToolIo(attrs));
     const status = objectValue(row.status);
     const message = stringValue(status?.message);
     return {
       trace_id: stringValue(row.trace_id) ?? hashId(row, 32),
       span_id: stringValue(row.span_id) ?? hashId({ row, field: "span" }),
       parent_span_id: stringValue(row.parent_span_id) || null,
-      name: stringValue(row.name) ?? "span",
+      name,
       start_time: stringValue(row.start_time) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
       end_time: stringValue(row.end_time) ?? stringValue(row.start_time) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
       status: { code: statusCode(status?.code), ...message ? { message } : {} },
@@ -3384,7 +4199,40 @@ function exportTraceEvidenceText(text, opts = {}) {
   return exportTraceEvidenceRows(parsed.rows, opts, parsed.wrapper);
 }
 async function exportTraceEvidenceFile(inputPath, opts = {}) {
-  const text = await readFile12(inputPath, "utf8");
+  if (/\.(?:jsonl|ndjson)$/i.test(inputPath)) {
+    let format;
+    const spans = [];
+    const sandboxRows = [];
+    let redactionCount = 0;
+    const redactionsByRule = {};
+    for await (const row of readJsonl(inputPath)) {
+      format ??= detectFormat([row], opts.format ?? "auto");
+      if (format === "sandbox-events") {
+        sandboxRows.push(row);
+        continue;
+      }
+      const converted = exportTraceEvidenceRows([row], {
+        ...opts,
+        sourcePath: inputPath,
+        format
+      });
+      spans.push(...converted.spans);
+      redactionCount += converted.redactionCount;
+      for (const [rule, count2] of Object.entries(converted.redactionsByRule)) {
+        redactionsByRule[rule] = (redactionsByRule[rule] ?? 0) + count2;
+      }
+    }
+    if (!format) throw new Error("input file is empty");
+    if (format === "sandbox-events") {
+      return exportTraceEvidenceRows(sandboxRows, {
+        ...opts,
+        sourcePath: inputPath,
+        format
+      });
+    }
+    return { format, spans, redactionCount, redactionsByRule };
+  }
+  const text = await readFile3(inputPath, "utf8");
   return exportTraceEvidenceText(text, { ...opts, sourcePath: inputPath });
 }
 async function writeTraceEvidenceExportFile(inputPath, outPath, opts = {}) {
@@ -3395,7 +4243,7 @@ async function writeTraceEvidenceExportFile(inputPath, outPath, opts = {}) {
 }
 
 // src/inspect.ts
-import { mkdtemp as mkdtemp3, readFile as readFile13, writeFile as writeFile3 } from "fs/promises";
+import { mkdtemp as mkdtemp3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
 import { basename as basename8, join as join15 } from "path";
 var severityRank = {
@@ -3674,14 +4522,14 @@ function assertSessionIndex(value) {
   }
   const candidate = value;
   if (candidate.kind !== "traces.session_index" || candidate.schemaVersion !== 1 || !Array.isArray(candidate.sessions)) {
-    throw new Error("input is not a traces.session_index v1 file");
+    throw new Error("input is not a traces.session_index file with schemaVersion 1");
   }
   if (!candidate.totals || typeof candidate.totals !== "object") {
     throw new Error("session index is missing totals");
   }
 }
 async function readSessionIndexFile(path) {
-  const parsed = JSON.parse(await readFile13(path, "utf8"));
+  const parsed = JSON.parse(await readFile4(path, "utf8"));
   assertSessionIndex(parsed);
   return parsed;
 }
@@ -3779,6 +4627,8 @@ function analyzeReactions(spans) {
 
 // src/report.ts
 var SEVERITY_RANK = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+var CORRUPTION_RECEIPT_DISPLAY_LIMIT = 100;
+var SOURCE_DISPLAY_LIMIT = 20;
 var SEVERITY_BADGE = {
   critical: "\u{1F534} CRITICAL",
   high: "\u{1F7E0} HIGH",
@@ -3790,23 +4640,105 @@ function deterministicSummaryText(summary) {
   const parts = [];
   if (summary.stuckLoops > 0) parts.push(`${summary.stuckLoops} stuck loop(s)`);
   if (summary.reactionSignals > 0) parts.push(`${summary.reactionSignals} human reaction signal(s)`);
-  if (summary.toolErrorRuns > 0) parts.push(`${summary.toolErrorRuns} tool-error run(s)`);
+  if (summary.failedRuns > 0) parts.push(`${summary.failedRuns} failed run(s)`);
   if (parts.length === 0) return "0 deterministic signals";
   if (parts.length === 1) return parts[0];
   return `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
 }
-function plural(count, singular, pluralForm = `${singular}s`) {
-  return count === 1 ? singular : pluralForm;
+function plural(count2, singular, pluralForm = `${singular}s`) {
+  return count2 === 1 ? singular : pluralForm;
+}
+function tableCell(value) {
+  return value.replace(/\s+/g, " ").replaceAll("|", "\\|").trim();
+}
+function count(value) {
+  return Math.round(value).toLocaleString("en-US");
+}
+function decimal(value, digits = 1) {
+  return value.toLocaleString("en-US", {
+    minimumFractionDigits: digits,
+    maximumFractionDigits: digits
+  });
+}
+function distributionRow(label, distribution, unit = "") {
+  if (distribution.n === 0) return `| ${label} | 0 | not captured | not captured | not captured | not captured | not captured |`;
+  const value = (number) => `${decimal(number)}${unit}`;
+  return `| ${label} | ${count(distribution.n)} | ${value(distribution.min)} | ${value(distribution.mean)} | ${value(distribution.p50)} | ${value(distribution.p95)} | ${value(distribution.max)} |`;
+}
+function tokenRows(usage) {
+  const rows = [
+    ["Input", usage.totals.input, usage.input],
+    ["Output", usage.totals.output, usage.output],
+    ["Reasoning (output subset)", usage.totals.reasoning, usage.reasoning],
+    ["Cache read", usage.totals.cached, usage.cached],
+    ["Cache write", usage.totals.cacheWrite, usage.cacheWrite]
+  ];
+  return rows.map(
+    ([label, total, values]) => `| ${label} | ${count(total)} | ${count(values.n)} | ${decimal(values.mean)} | ${decimal(values.p50)} | ${decimal(values.p95)} | ${count(values.max)} |`
+  );
+}
+function renderExecution(report) {
+  const execution = report.execution;
+  const lines = ["## execution facts", ""];
+  lines.push(
+    `- **Runs:** ${count(execution.durationMs.n)}  |  **Model-call runs:** ${count(execution.modelCalls.runs)}  |  **Model-call events:** ${count(execution.modelCalls.events)}  |  **Failed runs:** ${count(execution.failures.runs)}/${count(execution.failures.reportingRuns)} (${decimal(execution.failures.fraction * 100, 2)}%)`
+  );
+  lines.push("- **Task quality:** not measured; these traces do not include comparable task outcome labels.");
+  lines.push("");
+  lines.push("| Time | Runs measured | Min | Mean | p50 | p95 | Max |");
+  lines.push("|---|---:|---:|---:|---:|---:|---:|");
+  lines.push(distributionRow("Duration", execution.durationMs, "ms"));
+  lines.push(distributionRow("Queue", execution.queueMs, "ms"));
+  lines.push("");
+  lines.push("### Direct model usage");
+  lines.push("");
+  lines.push("| Token category | Total | Runs measured | Mean | p50 | p95 | Max |");
+  lines.push("|---|---:|---:|---:|---:|---:|---:|");
+  lines.push(...tokenRows(execution.tokenUsage));
+  lines.push("");
+  lines.push("| Model | Runs |");
+  lines.push("|---|---:|");
+  for (const model of execution.models) {
+    lines.push(`| \`${tableCell(model.model)}\` | ${count(model.runs)} |`);
+  }
+  lines.push("");
+  lines.push("### Cost coverage");
+  lines.push("");
+  lines.push("| Source | Runs | Total USD |");
+  lines.push("|---|---:|---:|");
+  lines.push(`| Observed | ${count(report.costProvenance.observed.n)} | $${report.costProvenance.observed.totalUsd.toFixed(6)} |`);
+  lines.push(`| Estimated | ${count(report.costProvenance.estimated.n)} | $${report.costProvenance.estimated.totalUsd.toFixed(6)} |`);
+  lines.push(`| Uncaptured | ${count(report.costProvenance.uncaptured.n)} | not available |`);
+  lines.push("");
+  lines.push(`Known cost coverage: ${decimal(report.costProvenance.knownFraction * 100, 2)}%.`);
+  lines.push("");
+  if (execution.aggregateUsage.runs > 0) {
+    lines.push("### Orchestration-reported usage");
+    lines.push("");
+    lines.push(
+      `Kept separate from direct model usage because orchestration totals can overlap model-call telemetry. ${count(execution.aggregateUsage.runs)} run(s) reported aggregate values.`
+    );
+    lines.push("");
+    lines.push("| Token category | Total | Runs measured | Mean | p50 | p95 | Max |");
+    lines.push("|---|---:|---:|---:|---:|---:|---:|");
+    lines.push(...tokenRows(execution.aggregateUsage.tokenUsage));
+    lines.push("");
+    lines.push(
+      `Aggregate cost: $${execution.aggregateUsage.totalCostUsd.toFixed(6)} across ${count(execution.aggregateUsage.costUsd.n)} reporting run(s).`
+    );
+    lines.push("");
+  }
+  return lines.join("\n");
 }
 function summarizeDeterministicSignals(pipelines, reactions) {
   const stuckLoops = pipelines.stuckLoops.findings.length;
-  const reactionSignals = Object.values(reactions.signals).reduce((total, count) => total + count, 0);
-  const toolErrorRuns2 = pipelines.toolUse.filter((run) => run.errorRate > 0).length;
+  const reactionSignals = Object.values(reactions.signals).reduce((total, count2) => total + count2, 0);
+  const failedRuns = pipelines.failureClusters.totalFailures;
   return {
     stuckLoops,
     reactionSignals,
-    toolErrorRuns: toolErrorRuns2,
-    totalSignals: stuckLoops + reactionSignals + toolErrorRuns2
+    failedRuns,
+    totalSignals: stuckLoops + reactionSignals + failedRuns
   };
 }
 function renderReport(result, meta) {
@@ -3814,14 +4746,93 @@ function renderReport(result, meta) {
   const findings = [...result.findings].sort(
     (a, b) => (SEVERITY_RANK[a.severity] ?? 9) - (SEVERITY_RANK[b.severity] ?? 9)
   );
-  const deterministic = meta.deterministic ?? { stuckLoops: 0, reactionSignals: 0, toolErrorRuns: 0, totalSignals: 0 };
-  const findingSummary = deterministic.totalSignals > 0 ? `${findings.length} analyst ${plural(findings.length, "finding")} + ${deterministic.totalSignals} deterministic ${plural(deterministic.totalSignals, "signal")}` : `${findings.length} ${plural(findings.length, "finding")}`;
+  const deterministic = meta.deterministic ?? { stuckLoops: 0, reactionSignals: 0, failedRuns: 0, totalSignals: 0 };
+  const findingSummary = deterministic.totalSignals > 0 ? `${findings.length} ${plural(findings.length, "finding")}; ${deterministic.totalSignals} raw deterministic ${plural(deterministic.totalSignals, "signal")}` : `${findings.length} ${plural(findings.length, "finding")}`;
   lines.push(`# Trace analysis \u2014 ${meta.harness}`);
   lines.push("");
+  const sessionSummary = meta.unassignedTraceCount ? `${meta.sessionCount} identified session(s) + ${meta.unassignedTraceCount} ${plural(meta.unassignedTraceCount, "trace")} without a single stable session identity` : `${meta.sessionCount} session(s)`;
   lines.push(
-    `${meta.sessionCount} session(s), ${meta.spanCount} spans \u2192 **${findingSummary}** across ${result.per_analyst.length} analyst(s). Cost: $${result.total_cost_usd.toFixed(4)}.`
+    `${sessionSummary}, ${meta.spanCount} spans \u2192 **${findingSummary}** across ${result.per_analyst.length} analyst(s). Analysis cost: $${result.total_cost_usd.toFixed(4)}.`
   );
   lines.push("");
+  if (meta.unassignedTraceCount) {
+    lines.push(
+      `> ${meta.unassignedTraceCount} ${plural(meta.unassignedTraceCount, "trace")} lacked a single stable session identity. Their spans were analyzed but were not relabeled as sessions.`
+    );
+    lines.push("");
+  }
+  lines.push(renderExecution(meta.execution));
+  lines.push("");
+  if (meta.sources && meta.sources.length > 0) {
+    lines.push("## Selected sessions");
+    lines.push("");
+    lines.push("| Role | Session ID | Parent session | Integrity | Subject (first prompt line) | Source path |");
+    lines.push("|---|---|---|---|---|---|");
+    for (const source of meta.sources.slice(0, SOURCE_DISPLAY_LIMIT)) {
+      const corruptionCount = source.corruptionCount ?? source.corruptions?.length ?? 0;
+      const integrity = source.integrity === "degraded_not_lossless" ? `degraded, not lossless (${corruptionCount} corrupt ${plural(corruptionCount, "record")})` : "complete";
+      lines.push(
+        `| ${source.role} | \`${tableCell(source.sessionId)}\` | ${source.parentSessionId ? `\`${tableCell(source.parentSessionId)}\`` : "\u2014"} | ${integrity} | ${tableCell(source.subject) || "(no prompt captured)"} | \`${tableCell(source.path)}\` |`
+      );
+    }
+    if (meta.sources.length > SOURCE_DISPLAY_LIMIT) {
+      lines.push(
+        `| \u2026 | ${meta.sources.length - SOURCE_DISPLAY_LIMIT} additional sessions omitted | \u2014 | \u2014 | \u2014 | \u2014 |`
+      );
+    }
+    lines.push("");
+    const childCount = meta.sources.filter((source) => source.role === "child").length;
+    if (childCount > 0) {
+      lines.push(
+        `> Scope: ${childCount}/${meta.sources.length} selected session(s) are children. Counts below describe only the selected files, not their parent operator sessions.`
+      );
+      lines.push("");
+    }
+    const totalCorruptionCount = meta.sources.reduce(
+      (total, source) => total + (source.corruptionCount ?? source.corruptions?.length ?? 0),
+      0
+    );
+    const corruptions = [];
+    for (const source of meta.sources) {
+      for (const receipt of source.corruptions ?? []) {
+        if (corruptions.length === CORRUPTION_RECEIPT_DISPLAY_LIMIT) break;
+        corruptions.push(receipt);
+      }
+      if (corruptions.length === CORRUPTION_RECEIPT_DISPLAY_LIMIT) break;
+    }
+    if (totalCorruptionCount > 0) {
+      lines.push("## Source corruption receipts");
+      lines.push("");
+      lines.push(
+        "> Degraded, not lossless: every valid JSONL record was analyzed. Malformed content is fingerprinted, not retained; exact bytes are retrievable only while the local source file still contains that byte range."
+      );
+      lines.push("");
+      for (const source of meta.sources) {
+        const count2 = source.corruptionCount ?? source.corruptions?.length ?? 0;
+        if (count2 === 0) continue;
+        const digest = source.corruptionDigest ? `, digest \`${source.corruptionDigest}\`` : "";
+        lines.push(`- Session \`${tableCell(source.sessionId)}\`: ${count2} ${plural(count2, "receipt")}${digest}.`);
+      }
+      lines.push("");
+      if (corruptions.length > 0) {
+        lines.push("| Session ID | Source path | Line | Byte offset | Byte length | SHA-256 | Raw bytes |");
+        lines.push("|---|---|---:|---:|---:|---|---|");
+        for (const receipt of corruptions) {
+          lines.push(
+            `| \`${tableCell(receipt.sessionId)}\` | \`${tableCell(receipt.sourcePath)}\` | ${receipt.lineNumber} | ${receipt.byteOffset} | ${receipt.byteLength} | \`${receipt.sha256}\` | local source only |`
+          );
+        }
+        lines.push("");
+      }
+      const omitted = totalCorruptionCount - corruptions.length;
+      if (omitted > 0) {
+        lines.push(
+          `_${omitted} additional ${plural(omitted, "receipt")} omitted from this report; all receipts remain in \`source.corruption.receipt\` child spans._`
+        );
+        lines.push("");
+      }
+    }
+  }
   lines.push("| Analyst | Status | Findings | Latency |");
   lines.push("|---|---|---|---|");
   for (const s of result.per_analyst) {
@@ -3829,7 +4840,7 @@ function renderReport(result, meta) {
   }
   lines.push("");
   if (findings.length === 0 && deterministic.totalSignals === 0) {
-    lines.push("_No findings \u2014 no behavioral inefficiencies or failure modes detected._");
+    lines.push("_No supported behavioral findings in the captured fields._");
   } else if (findings.length === 0) {
     lines.push(
       `_No analyst findings. Deterministic checks found ${deterministicSummaryText(deterministic)}; see sections below._`
@@ -3850,6 +4861,7 @@ function renderReport(result, meta) {
         if (f.subject) lines.push(`- **Subject:** \`${f.subject}\``);
         lines.push(`- **Confidence:** ${f.confidence}`);
         if (f.recommended_action) lines.push(`- **Fix:** ${f.recommended_action}`);
+        if (f.validation_plan) lines.push(`- **Check:** ${f.validation_plan}`);
         for (const ev of f.evidence_refs.slice(0, 3)) {
           const excerpt = ev.excerpt ? ` \u2014 \`${ev.excerpt.slice(0, 200)}\`` : "";
           lines.push(`- **Evidence:** ${ev.kind} ${ev.uri}${excerpt}`);
@@ -3864,20 +4876,79 @@ function renderReport(result, meta) {
   return lines.join("\n");
 }
 function renderPipelines(pr) {
-  const lines = ["## loops & waste (deterministic)", ""];
+  const lines = ["## reliability, loops & waste (deterministic)", ""];
+  lines.push(
+    `- **Execution failures:** ${pr.failureClusters.totalFailures}/${pr.failureClusters.totalRuns} run(s)`
+  );
+  if (pr.failureClusters.clusters.length > 0) {
+    lines.push("");
+    lines.push("| Failure class | Runs | Tool | Example trace | Example error |");
+    lines.push("|---|---:|---|---|---|");
+    for (const cluster of pr.failureClusters.clusters.slice(0, 10)) {
+      lines.push(
+        `| ${tableCell(cluster.failureClass)} | ${cluster.runCount} | ${cluster.toolName ? `\`${tableCell(cluster.toolName)}\`` : "not captured"} | ${cluster.exampleRunId ? `\`${tableCell(cluster.exampleRunId)}\`` : "not captured"} | ${tableCell(cluster.exampleError ?? "not captured")} |`
+      );
+    }
+    lines.push("");
+  }
   if (pr.stuckLoops.findings.length === 0) {
-    lines.push("- **Stuck loops:** none (no tool called \u22653\xD7 with identical args).");
+    lines.push("- **Stuck loops:** none (no tool called \u22653\xD7 with identical args in a short interval).");
   } else {
     lines.push(`- **Stuck loops:** ${pr.stuckLoops.findings.length} (${(pr.stuckLoops.affectedRunRatio * 100).toFixed(0)}% of runs affected)`);
     for (const f of pr.stuckLoops.findings.sort((a, b) => b.occurrences - a.occurrences).slice(0, 10)) {
       lines.push(`  - \u{1F501} \`${f.toolName}\` \xD7${f.occurrences} with identical args over ${(f.windowMs / 1e3).toFixed(1)}s`);
     }
   }
-  for (const m of pr.toolUse) {
-    if (m.totalCalls === 0) continue;
+  const runsWithTools = pr.toolUse.filter((metrics) => metrics.totalCalls > 0);
+  if (runsWithTools.length > 0) {
+    let totalCalls = 0;
+    let callsWithCapturedArgs = 0;
+    let duplicateCalls = 0;
+    let errorCalls = 0;
+    let followedFailures = 0;
+    const byTool = /* @__PURE__ */ new Map();
+    for (const metrics of runsWithTools) {
+      const toolStats = Object.values(metrics.byTool);
+      const duplicates = toolStats.length > 0 ? toolStats.reduce((total, stats) => total + stats.duplicates, 0) : Math.round(metrics.duplicateRate * metrics.totalCalls);
+      const errors = toolStats.length > 0 ? toolStats.reduce((total, stats) => total + stats.errors, 0) : Math.round(metrics.errorRate * metrics.totalCalls);
+      totalCalls += metrics.totalCalls;
+      callsWithCapturedArgs += metrics.callsWithCapturedArgs;
+      duplicateCalls += duplicates;
+      errorCalls += errors;
+      followedFailures += Math.round(metrics.retryRate * errors);
+      for (const [name, stats] of Object.entries(metrics.byTool)) {
+        const aggregate = byTool.get(name) ?? {
+          calls: 0,
+          captured: 0,
+          duplicates: 0,
+          errors: 0,
+          latencyMs: 0
+        };
+        aggregate.calls += stats.calls;
+        aggregate.captured += stats.callsWithCapturedArgs;
+        aggregate.duplicates += stats.duplicates;
+        aggregate.errors += stats.errors;
+        aggregate.latencyMs += stats.avgLatencyMs * stats.calls;
+        byTool.set(name, aggregate);
+      }
+    }
+    const failureFollowUp = errorCalls > 0 ? `; ${followedFailures}/${errorCalls} failed calls followed by another same-tool call (${(followedFailures / errorCalls * 100).toFixed(0)}%)` : "";
+    const duplicateSummary = callsWithCapturedArgs > 0 ? `${duplicateCalls}/${callsWithCapturedArgs} captured calls repeated exactly` : "exact repeats unavailable";
     lines.push(
-      `- **Tool use** (${m.totalCalls} calls): ${(m.duplicateRate * 100).toFixed(0)}% duplicate, ${(m.retryRate * 100).toFixed(0)}% retry, ${(m.errorRate * 100).toFixed(0)}% error`
+      `- **Tool use:** ${totalCalls} calls across ${runsWithTools.length}/${pr.toolUse.length} traces; ${callsWithCapturedArgs}/${totalCalls} arguments captured; ${duplicateSummary}; ${errorCalls}/${totalCalls} failed${failureFollowUp}`
     );
+    if (byTool.size > 0) {
+      lines.push("");
+      lines.push("| Tool | Calls | Args captured | Exact repeats | Errors | Mean latency |");
+      lines.push("|---|---:|---:|---:|---:|---:|");
+      for (const [name, stats] of [...byTool].sort(
+        (left, right) => right[1].calls - left[1].calls || left[0].localeCompare(right[0])
+      )) {
+        lines.push(
+          `| \`${tableCell(name)}\` | ${stats.calls} | ${stats.captured}/${stats.calls} | ${stats.duplicates}/${stats.captured} | ${stats.errors}/${stats.calls} | ${(stats.latencyMs / stats.calls).toFixed(1)}ms |`
+        );
+      }
+    }
   }
   lines.push("");
   return lines.join("\n");
@@ -3931,14 +5002,41 @@ function renderReactions(rr) {
 }
 function renderAdoption(ar) {
   const lines = ["## skill & subagent adoption (deterministic)", ""];
+  const scopeParts = [`${ar.identifiedSessionCount} identified session(s)`];
+  if (ar.unassignedTraceCount > 0) {
+    scopeParts.push(`${ar.unassignedTraceCount} trace(s) without a single stable session identity`);
+  }
+  lines.push(`- **Scope:** ${scopeParts.join(" + ")}`);
+  if (ar.sessionIdentityConflicts.length > 0) {
+    const displayed = ar.sessionIdentityConflicts.slice(0, SOURCE_DISPLAY_LIMIT);
+    const details = displayed.map((conflict) => `\`${conflict.traceId}\` (${conflict.sessionIds.map((id) => `\`${id}\``).join(", ")})`).join("; ");
+    const omitted = ar.sessionIdentityConflicts.length - displayed.length;
+    lines.push(
+      `- **Conflicting session identity:** ${ar.sessionIdentityConflicts.length} trace(s): ${details}${omitted > 0 ? `; ${omitted} more omitted from this report` : ""}`
+    );
+  }
+  lines.push(
+    "- **Prompt, tools, MCP, hooks, and full agent profile:** not assessed; no baseline profile was supplied."
+  );
+  if (ar.skillPenetration === null) {
+    const label = ar.skillTelemetryStatus === "unsupported" ? "uncaptured/unsupported" : "uncaptured/unknown";
+    lines.push(
+      `- **Explicit skill invocation rate:** ${label} (${ar.skillTelemetrySessions}/${ar.executionGroupCount} observed group(s) expose a dedicated Skill event)`
+    );
+  } else {
+    const excluded = ar.executionGroupCount - ar.skillTelemetrySessions;
+    lines.push(
+      `- **Explicit skill invocation rate:** ${(ar.skillPenetration * 100).toFixed(0)}% (${ar.sessionsWithSkill}/${ar.skillTelemetrySessions} measurable group(s)${excluded > 0 ? `; ${excluded} unmeasurable group(s) excluded` : ""})`
+    );
+  }
   lines.push(
-    `- **Skill penetration:** ${(ar.skillPenetration * 100).toFixed(0)}% (${ar.sessionsWithSkill}/${ar.sessionCount} session(s) invoked a skill explicitly)`
+    `- **Materialized skill catalogs/instructions:** ${ar.sessionsWithMaterializedSkills}/${ar.executionGroupCount} observed group(s)  \xB7  **SKILL.md tool references:** ${ar.sessionsWithSkillFileReference}/${ar.executionGroupCount} observed group(s)`
   );
   lines.push(
     `- **Explicit skill invocations:** ${ar.totalSkillInvocations} (Skill tool spans)  \xB7  **Loop-dispatched runs:** ${ar.totalLoopDispatchedRuns} (from ${ar.skillRunFilesRead} \`.evolve/skill-runs.jsonl\` file(s))`
   );
   lines.push(
-    `- **Subagent spawns:** ${ar.totalSubagentSpawns} across ${ar.sessionsWithSubagent} session(s)`
+    `- **Subagent spawns observed:** ${ar.totalSubagentSpawns} across ${ar.sessionsWithSubagent} observed group(s); capture completeness depends on source telemetry.`
   );
   lines.push("");
   const skillRows = Object.entries(ar.skillInvocations).sort((a, b) => b[1] - a[1]);
@@ -3981,9 +5079,6 @@ var severityRank2 = {
   low: 3,
   info: 4
 };
-function slug(input) {
-  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 72) || "item";
-}
 function json(value) {
   return `${JSON.stringify(value, null, 2)}
 `;
@@ -3996,13 +5091,76 @@ function evidence(kind, uri, excerpt) {
   return excerpt ? { kind, uri, excerpt } : { kind, uri };
 }
 function totalReactionSignals(reactions) {
-  return Object.values(reactions.signals).reduce((sum, count) => sum + count, 0);
+  return Object.values(reactions.signals).reduce((sum, count2) => sum + count2, 0);
 }
-function toolErrorRuns(pipelines) {
-  return pipelines.toolUse.filter((run) => run.errorRate > 0).length;
+function traceCoverageFinding(pipelines, adoption) {
+  const toolCalls = pipelines.toolUse.reduce((total, run) => total + run.totalCalls, 0);
+  const capturedToolCalls = pipelines.toolUse.reduce(
+    (total, run) => total + run.callsWithCapturedArgs,
+    0
+  );
+  const missingToolArgs = toolCalls - capturedToolCalls;
+  const traces = pipelines.toolUse.length;
+  const missingSessionIds = adoption.unassignedTraceCount;
+  const sessionIdentityConflicts = adoption.sessionIdentityConflicts;
+  const unmeasurableSkillGroups = adoption.executionGroupCount - adoption.skillTelemetrySessions;
+  if (missingToolArgs === 0 && missingSessionIds === 0 && unmeasurableSkillGroups === 0) {
+    return void 0;
+  }
+  const parts = [];
+  const refs = [];
+  if (missingToolArgs > 0) {
+    parts.push(`${missingToolArgs}/${toolCalls} tool call(s) lacked comparable arguments`);
+    refs.push(evidence("metric", "coverage.tool_arguments", `${capturedToolCalls}/${toolCalls} captured`));
+  }
+  if (missingSessionIds > 0) {
+    parts.push(`${missingSessionIds}/${traces} trace(s) lacked a single stable session identity`);
+    refs.push(evidence("metric", "coverage.session_identity", `${traces - missingSessionIds}/${traces} identified`));
+  }
+  if (sessionIdentityConflicts.length > 0) {
+    refs.push(evidence(
+      "span",
+      "coverage.session_identity_conflicts",
+      sessionIdentityConflicts.map((conflict) => conflict.traceId).join(", ")
+    ));
+  }
+  if (unmeasurableSkillGroups > 0) {
+    parts.push(`${unmeasurableSkillGroups}/${adoption.executionGroupCount} execution group(s) lacked measurable skill events`);
+    refs.push(evidence(
+      "metric",
+      "coverage.skill_events",
+      `${adoption.skillTelemetrySessions}/${adoption.executionGroupCount} measurable`
+    ));
+  }
+  const argumentCoverage = toolCalls === 0 ? 1 : capturedToolCalls / toolCalls;
+  const sessionCoverage = traces === 0 ? 1 : (traces - missingSessionIds) / traces;
+  const severity = argumentCoverage < 0.5 || sessionCoverage < 0.5 ? "high" : argumentCoverage < 0.9 || sessionCoverage < 0.9 || unmeasurableSkillGroups > 0 ? "medium" : "low";
+  return makeFinding({
+    analyst_id: "traces-deterministic",
+    area: "instrumentation",
+    claim: `Trace capture is incomplete: ${parts.join("; ")}`,
+    severity,
+    rationale: "Missing identity or agent-profile evidence prevents reliable cross-run comparison and can hide tool, prompt, skill, or subagent failures.",
+    evidence_refs: refs,
+    recommended_action: "Update the source telemetry bridge once: emit a stable session ID, complete canonical tool arguments, explicit argument-capture status, and dedicated skill/subagent events before optimizing the agent profile.",
+    validation_plan: "Rerun the same source and require every trace to carry exactly one session identity, every tool call to declare and preserve its full arguments, and every supported execution group to expose skill events.",
+    confidence: 1,
+    metadata: {
+      source: "traces.coverage",
+      toolCalls,
+      capturedToolCalls,
+      traces,
+      missingSessionIds,
+      sessionIdentityConflictCount: sessionIdentityConflicts.length,
+      skillTelemetryGroups: adoption.skillTelemetrySessions,
+      executionGroups: adoption.executionGroupCount
+    }
+  });
 }
 function deterministicFindings(pipelines, reactions, adoption) {
   const findings = [];
+  const coverage = traceCoverageFinding(pipelines, adoption);
+  if (coverage) findings.push(coverage);
   const loops = pipelines.stuckLoops.findings;
   if (loops.length > 0) {
     const top = [...loops].sort((a, b) => b.occurrences - a.occurrences)[0];
@@ -4022,19 +5180,34 @@ function deterministicFindings(pipelines, reactions, adoption) {
       metadata: { source: "traces.pipeline.stuckLoopView", loopCount: loops.length }
     }));
   }
-  const erroredRuns = toolErrorRuns(pipelines);
-  if (erroredRuns > 0) {
+  const failedRuns = pipelines.failureClusters.totalFailures;
+  if (failedRuns > 0) {
+    const top = pipelines.failureClusters.clusters[0];
+    const failureRate = failedRuns / Math.max(1, pipelines.failureClusters.totalRuns);
     findings.push(makeFinding({
       analyst_id: "traces-deterministic",
-      area: "tool-use",
-      claim: `${erroredRuns} run(s) included tool errors`,
-      severity: erroredRuns >= 5 ? "high" : "medium",
-      rationale: "Tool errors are expensive when the agent keeps planning as if the call succeeded.",
-      evidence_refs: [evidence("metric", "pipelines.tool_error_runs", `${erroredRuns} run(s) with errorRate > 0`)],
-      recommended_action: "Fix the highest-frequency failing tool path first, then make the agent inspect failure output before retrying.",
-      validation_plan: "Rerun the same trace window and require the tool-error run count and repeated retries to decrease.",
-      confidence: 0.9,
-      metadata: { source: "traces.pipeline.computeToolUseMetrics", erroredRuns }
+      area: "reliability",
+      claim: `${failedRuns}/${pipelines.failureClusters.totalRuns} run(s) had execution errors`,
+      severity: failureRate >= 0.1 ? "high" : "medium",
+      rationale: "Execution errors consume time and tokens, and sparse error telemetry can hide whether the agent recovered or repeated the same failure.",
+      evidence_refs: [
+        evidence(
+          "metric",
+          `pipelines.failure_cluster.${top?.failureClass ?? "unknown"}`,
+          top ? `${top.runCount} run(s); example: ${top.exampleError ?? "error details not captured"}` : `${failedRuns} failed run(s)`
+        ),
+        ...top?.exampleRunId ? [evidence("span", `trace:${top.exampleRunId}`, top.exampleError)] : []
+      ],
+      recommended_action: top?.failureClass === "unknown" ? "Instrument the failing operation name and arguments, then start with the highest-frequency example error and verify the agent changes state before retrying." : "Fix the highest-frequency failure cluster first, then require the agent to inspect the error and change state before retrying.",
+      validation_plan: "Rerun a comparable trace window and require failed runs and repeated failures in the top cluster to decrease.",
+      confidence: 1,
+      metadata: {
+        source: "agent-eval.failureClusterView",
+        failedRuns,
+        totalRuns: pipelines.failureClusters.totalRuns,
+        topFailureClass: top?.failureClass,
+        exampleRunId: top?.exampleRunId
+      }
     }));
   }
   const corrective = reactions.signals.correction + reactions.signals.frustration + reactions.signals.jargon + reactions.signals.structure;
@@ -4053,7 +5226,8 @@ function deterministicFindings(pipelines, reactions, adoption) {
     }));
   }
   const skillRuns = adoption.totalSkillInvocations + adoption.totalLoopDispatchedRuns;
-  if (adoption.sessionCount > 0 && skillRuns === 0) {
+  const allSessionsMeasurable = adoption.skillTelemetrySessions === adoption.executionGroupCount;
+  if (allSessionsMeasurable && adoption.executionGroupCount > 0 && skillRuns === 0) {
     findings.push(makeFinding({
       analyst_id: "traces-deterministic",
       area: "workflow",
@@ -4064,7 +5238,7 @@ function deterministicFindings(pipelines, reactions, adoption) {
       recommended_action: "Create or invoke a narrow skill for the repeated workflow, then let traces compare future sessions against this baseline.",
       validation_plan: "Rerun traces and require skill-run attribution to appear for repeated workflows.",
       confidence: 0.75,
-      metadata: { source: "traces.adoption", sessionCount: adoption.sessionCount }
+      metadata: { source: "traces.adoption", executionGroupCount: adoption.executionGroupCount }
     }));
   }
   return findings;
@@ -4125,41 +5299,6 @@ function normalizeExternalFindings(results) {
   }
   return out;
 }
-function sourceOf(finding2) {
-  if (finding2.analyst_id.startsWith("external:")) return "external";
-  if (finding2.analyst_id === "traces-deterministic") return "deterministic";
-  return "analyst";
-}
-function recommendationTitle(finding2) {
-  if (finding2.recommended_action) return finding2.recommended_action.replace(/\.$/, "");
-  return `Investigate ${finding2.area}: ${finding2.claim}`.replace(/\.$/, "");
-}
-function buildRecommendations(findings) {
-  return [...findings].filter((finding2) => finding2.severity !== "info").sort((a, b) => severityRank2[a.severity] - severityRank2[b.severity] || b.confidence - a.confidence || a.finding_id.localeCompare(b.finding_id)).slice(0, 20).map((finding2, index) => ({
-    schemaVersion: 1,
-    id: `rec-${index + 1}-${slug(finding2.area)}`,
-    severity: finding2.severity,
-    title: recommendationTitle(finding2),
-    action: finding2.recommended_action ?? `Review and fix: ${finding2.claim}`,
-    rationale: finding2.rationale ?? finding2.claim,
-    evidenceRefs: finding2.evidence_refs,
-    findingIds: [finding2.finding_id],
-    validationPlan: finding2.validation_plan ?? "Rerun `traces improve` on a fresh comparable session window and confirm this finding disappears or drops in severity.",
-    source: sourceOf(finding2)
-  }));
-}
-function buildClaims(findings) {
-  return findings.map((finding2, index) => ({
-    schemaVersion: 1,
-    id: `claim-${index + 1}-${slug(finding2.area)}`,
-    severity: finding2.severity,
-    text: finding2.claim,
-    area: finding2.area,
-    sourceFindingId: finding2.finding_id,
-    evidenceRefs: finding2.evidence_refs,
-    validationPlan: finding2.validation_plan
-  }));
-}
 function buildEvidenceRows(findings) {
   return findings.flatMap((finding2) => finding2.evidence_refs.map((ref) => ({
     schemaVersion: 1,
@@ -4171,31 +5310,10 @@ function buildEvidenceRows(findings) {
     evidence: ref
   })));
 }
-function renderRecommendations(recommendations) {
-  const lines = ["## recommendations", ""];
-  if (recommendations.length === 0) {
-    lines.push("- No recommendations emitted.");
-    lines.push("");
-    return lines.join("\n");
-  }
-  for (const rec of recommendations.slice(0, 10)) {
-    lines.push(`### ${rec.severity.toUpperCase()} \u2014 ${rec.title}`);
-    lines.push("");
-    lines.push(`- **Action:** ${rec.action}`);
-    lines.push(`- **Why:** ${rec.rationale}`);
-    lines.push(`- **Check:** ${rec.validationPlan}`);
-    for (const ref of rec.evidenceRefs.slice(0, 3)) {
-      lines.push(`- **Evidence:** ${ref.kind} ${ref.uri}${ref.excerpt ? ` \u2014 \`${ref.excerpt.slice(0, 180)}\`` : ""}`);
-    }
-    lines.push("");
-  }
-  return lines.join("\n");
-}
 function renderFindingPacket(packet, title = "Trace finding packet") {
   const lines = [`# ${title}`, ""];
-  lines.push(`${packet.findings.length} finding(s), ${packet.recommendations.length} recommendation(s), ${packet.claims.length} claim(s).`);
+  lines.push(`${packet.findings.length} evidence-backed finding(s) with actions and checks.`);
   lines.push("");
-  lines.push(renderRecommendations(packet.recommendations));
   if (packet.findings.length > 0) {
     lines.push("## findings");
     lines.push("");
@@ -4221,33 +5339,10 @@ function buildTraceFindingPacket(opts) {
     kind: "traces.finding_packet",
     generatedAt,
     source: opts.source ?? "traces",
-    findings: opts.findings,
-    recommendations: buildRecommendations(opts.findings),
-    claims: buildClaims(opts.findings)
+    findings: opts.findings
   };
   return { ...packet, report: renderFindingPacket(packet, opts.title) };
 }
-function buildDefaultImprovementProposals(input) {
-  return input.recommendations.slice(0, 5).map((recommendation, index) => {
-    const matchingFindings = input.findings.filter((finding2) => recommendation.findingIds.includes(finding2.finding_id));
-    const evidenceRefs = recommendation.evidenceRefs.length > 0 ? recommendation.evidenceRefs : matchingFindings.flatMap((finding2) => finding2.evidence_refs);
-    return {
-      id: `proposal-${index + 1}-${slug(recommendation.title)}`,
-      title: recommendation.title,
-      description: [
-        recommendation.action,
-        "",
-        `Why: ${recommendation.rationale}`,
-        `Validation: ${recommendation.validationPlan}`,
-        "",
-        "This is a proposal-only artifact. It does not mutate code, prompts, skills, tools, MCP config, hooks, subagents, or external systems until a human applies it and reruns validation."
-      ].join("\n"),
-      recommendationIds: [recommendation.id],
-      validationCommand: "traces improve --last 1 --dir .traces/improvement",
-      evidenceRefs
-    };
-  });
-}
 function renderExternal(results) {
   if (results.length === 0) return "";
   const lines = ["## external analyzers", ""];
@@ -4263,11 +5358,13 @@ function renderInvestigationReport(result, analystResult) {
   const base = `${renderReport({ ...analystResult, findings: [...result.findings] }, {
     harness: result.harness,
     sessionCount: result.sessionCount,
+    unassignedTraceCount: result.unassignedTraceCount,
     spanCount: result.spanCount,
     otlpPath: result.otlpPath,
-    deterministic: summarizeDeterministicSignals(result.pipelines, result.reactions)
+    execution: result.execution,
+    deterministic: summarizeDeterministicSignals(result.pipelines, result.reactions),
+    sources: result.sources
   })}
-${renderRecommendations(result.recommendations)}
 ${renderPipelines(result.pipelines)}
 ${renderReactions(result.reactions)}
 ${renderAdoption(result.adoption)}`;
@@ -4344,19 +5441,18 @@ async function runTraceInvestigation(opts) {
     ...deterministicFindings(pipelines, reactions, adoption),
     ...normalizeExternalFindings(external)
   ];
-  const recommendations = buildRecommendations(findings);
-  const claims = buildClaims(findings);
   const partial = {
     schemaVersion: 1,
     kind: "traces.investigation",
     generatedAt,
     harness: opts.harness,
-    sessionCount: opts.sessionCount,
+    sessionCount: adoption.identifiedSessionCount,
+    unassignedTraceCount: adoption.unassignedTraceCount,
+    sources: opts.sources,
     spanCount: opts.spans.length,
     otlpPath: analysis.otlpPath,
+    execution: analysis.execution,
     findings,
-    recommendations,
-    claims,
     pipelines,
     reactions,
     adoption,
@@ -4388,70 +5484,38 @@ async function runTraceStoreInvestigation(opts) {
     analystResult
   };
 }
-function replayProof(result, proposals) {
-  const deterministic = summarizeDeterministicSignals(result.pipelines, result.reactions);
-  return {
-    schemaVersion: 1,
-    kind: "traces.improvement_replay",
-    generatedAt: result.generatedAt,
-    status: proposals.length > 0 ? "proposal-only" : "not-run",
-    candidateApplied: false,
-    baseline: {
-      spanCount: result.spanCount,
-      findingCount: result.findings.length,
-      recommendationCount: result.recommendations.length,
-      stuckLoops: deterministic.stuckLoops,
-      reactionSignals: deterministic.reactionSignals,
-      toolErrorRuns: deterministic.toolErrorRuns
-    },
-    proposals,
-    note: proposals.length > 0 ? "traces produced reviewable proposals only; apply one and rerun traces on a comparable window to populate after metrics." : "no proposal adapter was configured, so no candidate was applied; recommendations remain reviewable guidance."
-  };
-}
 async function writeTraceImprovementArtifacts(result, outDir) {
   const directory = outDir ? resolve(outDir) : await mkdtemp4(join16(tmpdir4(), "traces-improvement-"));
   await mkdir(directory, { recursive: true });
   const paths = {
     directory,
-    findings: join16(directory, "findings.json"),
-    recommendations: join16(directory, "recommendations.json"),
-    proposals: join16(directory, "proposals.json"),
+    result: join16(directory, "result.json"),
     evidence: join16(directory, "evidence.jsonl"),
-    claims: join16(directory, "claims.json"),
     report: join16(directory, "report.md"),
-    replay: join16(directory, "replay-before-after.json")
+    traces: result.otlpPath
   };
+  const { report, ...machineResult } = result;
   await Promise.all([
-    writeFile4(paths.findings, json(result.findings), "utf8"),
-    writeFile4(paths.recommendations, json(result.recommendations), "utf8"),
-    writeFile4(paths.proposals, json(result.proposals), "utf8"),
+    writeFile4(paths.result, json(machineResult), "utf8"),
     writeFile4(paths.evidence, jsonl(buildEvidenceRows(result.findings)), "utf8"),
-    writeFile4(paths.claims, json(result.claims), "utf8"),
-    writeFile4(paths.report, result.report, "utf8"),
-    writeFile4(paths.replay, json(result.replay), "utf8")
+    writeFile4(paths.report, report, "utf8")
   ]);
   return paths;
 }
-async function runTraceImprovementLoop(opts) {
-  const investigation = await runTraceInvestigation(opts);
-  const adapterInput = {
-    findings: investigation.findings,
-    recommendations: investigation.recommendations,
-    claims: investigation.claims,
-    spans: opts.spans,
-    otlpPath: investigation.otlpPath
-  };
-  const proposals = opts.adapter ? await opts.adapter.propose(adapterInput) : buildDefaultImprovementProposals(adapterInput);
-  const replay = replayProof(investigation, proposals);
+async function runTraceImprovement(opts) {
+  const directory = opts.outDir ? resolve(opts.outDir) : await mkdtemp4(join16(tmpdir4(), "traces-improvement-"));
+  await mkdir(directory, { recursive: true });
+  const investigation = await runTraceInvestigation({
+    ...opts,
+    otlpOutPath: opts.otlpOutPath ?? join16(directory, "traces.otlp.jsonl")
+  });
   const result = {
     ...investigation,
-    kind: "traces.improvement",
-    proposals,
-    replay
+    kind: "traces.improvement"
   };
   return {
     ...result,
-    artifacts: await writeTraceImprovementArtifacts(result, opts.outDir)
+    artifacts: await writeTraceImprovementArtifacts(result, directory)
   };
 }
 async function saveReport(path, report) {
@@ -4460,7 +5524,7 @@ async function saveReport(path, report) {
 }
 
 // src/live.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash5 } 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;
@@ -4480,7 +5544,7 @@ var sleep = (ms, signal) => new Promise((resolve2) => {
   signal?.addEventListener("abort", onAbort, { once: true });
 });
 function hash(parts) {
-  return createHash2("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
+  return createHash5("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
 }
 function asString(value) {
   if (typeof value === "string" && value.trim()) return value;
@@ -4934,7 +5998,7 @@ async function watchSessions(opts) {
 }
 
 // src/session-index.ts
-import { mkdtemp as mkdtemp5, readdir as readdir11, readFile as readFile14, stat as stat12, writeFile as writeFile5 } from "fs/promises";
+import { mkdtemp as mkdtemp5, readdir as readdir12, readFile as readFile5, stat as stat12, writeFile as writeFile5 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
 import { dirname as dirname3, join as join17 } from "path";
 function indexRow(record) {
@@ -4956,7 +6020,8 @@ function indexRow(record) {
     },
     models: record.metrics.models,
     tools: record.metrics.tools,
-    signals: record.signals
+    signals: record.signals,
+    execution: record.execution
   };
 }
 function uniqueSorted(values) {
@@ -5051,7 +6116,7 @@ async function summarizeFile(path, kind) {
   const base = { kind, path, bytes: Number(s.size), mtimeMs: Number(s.mtimeMs) };
   if (!path.endsWith(".md") && !path.endsWith(".jsonl")) return base;
   try {
-    const text = await readFile14(path, "utf8");
+    const text = await readFile5(path, "utf8");
     const lines = countLines(text);
     const jsonl2 = path.endsWith(".jsonl") ? summarizeJsonl(text) : void 0;
     return {
@@ -5070,7 +6135,7 @@ async function walkMarkdown(root, kind, maxFiles = 100) {
     if (out.length >= maxFiles) return;
     let entries;
     try {
-      entries = await readdir11(dir, { withFileTypes: true });
+      entries = await readdir12(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -5156,10 +6221,10 @@ async function writeSessionIndexFile(index, outPath) {
 }
 
 // src/upload-state.ts
-import { createHash as createHash3 } from "crypto";
-import { mkdir as mkdir2, readFile as readFile15, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir11 } from "os";
 import { dirname as dirname4, join as join18 } from "path";
+import { contentHash } from "@tangle-network/agent-eval";
 function stateFile() {
   const base = process.env.XDG_STATE_HOME ?? join18(homedir11(), ".local", "state");
   return join18(base, "tangle-traces", "uploaded.json");
@@ -5168,16 +6233,14 @@ function uploadKey(harness, sessionId) {
   return `${harness}:${sessionId}`;
 }
 function sessionHash(spans) {
-  const h = createHash3("sha256");
-  for (const s of spans) {
-    h.update(`${s.span_id}\0${s.name}\0${s.start_time}\0${s.status.code}
-`);
-  }
-  return h.digest("hex").slice(0, 32);
+  return contentHash(spans).slice(0, 32);
+}
+function outboundHash(events, identity) {
+  return contentHash({ events, identity }).slice(0, 32);
 }
 async function loadState() {
   try {
-    return JSON.parse(await readFile15(stateFile(), "utf8"));
+    return JSON.parse(await readFile6(stateFile(), "utf8"));
   } catch {
     return {};
   }
@@ -5193,7 +6256,7 @@ function alreadyUploaded(state, harness, sessionId, hash2) {
 }
 
 // src/upload.ts
-import { readFile as readFile16 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 import { createRequire } from "module";
 import { hostname } from "os";
 import { basename as basename9, join as join19 } from "path";
@@ -5212,7 +6275,7 @@ async function planUpload(opts = {}) {
       spans,
       redaction: report,
       hash: hash2,
-      isNew: !alreadyUploaded(state, ref.harness, ref.sessionId, hash2)
+      isNew: true
     });
   }
   return { items, state, sinceMs: opts.sinceMs };
@@ -5220,19 +6283,18 @@ async function planUpload(opts = {}) {
 async function gitBranch(cwd) {
   if (!cwd) return void 0;
   try {
-    const head = await readFile16(join19(cwd, ".git", "HEAD"), "utf8");
+    const head = await readFile7(join19(cwd, ".git", "HEAD"), "utf8");
     const m = head.match(/^ref:\s*refs\/heads\/(.+)$/m);
     return m?.[1]?.trim();
   } catch {
     return void 0;
   }
 }
-async function sessionMeta(item, uploadedAt) {
+async function sessionMeta(item) {
   const meta = {
     [ATTR.HARNESS]: item.ref.harness,
     [ATTR.SESSION_FILE]: basename9(item.ref.path),
     [ATTR.HOST]: hostname(),
-    [ATTR.UPLOADED_AT]: uploadedAt,
     [ATTR.UPLOADER]: `tangle-traces@${TRACES_VERSION}`,
     [ATTR.REDACTION_VERSION]: REDACTION_VERSION,
     [ATTR.REDACTION_COUNT]: item.redaction.redactionCount
@@ -5266,25 +6328,69 @@ function toTraceSpanEvents(spans, rootMeta) {
     };
   });
 }
+var PartialUploadError = class extends Error {
+  sessionKey;
+  accepted;
+  expected;
+  constructor(sessionKey, accepted, expected) {
+    super(`upload: backend accepted ${accepted} of ${expected} spans for ${sessionKey}`);
+    this.name = "PartialUploadError";
+    this.sessionKey = sessionKey;
+    this.accepted = accepted;
+    this.expected = expected;
+  }
+};
 function stripSpanContent(spans) {
   return spans.map((s) => {
-    if (s.attributes["content"] == null) return s;
-    const { content: _drop, ...attributes } = s.attributes;
-    return { ...s, attributes };
+    const attributes = { ...s.attributes };
+    delete attributes.content;
+    for (const key of TOOL_IO_VALUE_KEYS) delete attributes[key];
+    normalizeToolIoAttributes(attributes);
+    const status = s.status.message ? { code: s.status.code } : s.status;
+    return { ...s, attributes, status };
   });
 }
-async function executeUpload(plan, opts = {}) {
-  let newItems = plan.items.filter((i) => i.isNew);
+async function prepareOutbound(plan, opts, uploadedAt) {
+  let candidates = plan.items;
   if (opts.redactor && !opts.stripContent) {
-    const r = opts.redactor;
-    newItems = await Promise.all(newItems.map(async (i) => ({ ...i, spans: (await applyRedactor(i.spans, r)).spans })));
+    const redactor = opts.redactor;
+    candidates = await Promise.all(
+      candidates.map(async (item) => ({ ...item, spans: (await applyRedactor(item.spans, redactor)).spans }))
+    );
   }
-  if (opts.stripContent) newItems = newItems.map((i) => ({ ...i, spans: stripSpanContent(i.spans) }));
-  const skipped = plan.items.length - newItems.length;
-  const redactionCount = newItems.reduce((n, i) => n + i.redaction.redactionCount, 0);
+  if (opts.stripContent) {
+    candidates = candidates.map((item) => ({ ...item, spans: stripSpanContent(item.spans) }));
+  }
+  const identity = {
+    stripContent: opts.stripContent === true,
+    redactor: opts.stripContent ? null : opts.redactor?.name ?? null,
+    redactionVersion: REDACTION_VERSION
+  };
+  const items = [];
+  for (const item of candidates) {
+    const key = uploadKey(item.ref.harness, item.ref.sessionId);
+    const previous = plan.state[key];
+    const meta = await sessionMeta(item);
+    const eventsAt = (timestamp) => toTraceSpanEvents(item.spans, { ...meta, [ATTR.UPLOADED_AT]: timestamp });
+    let eventTimestamp2 = previous?.uploadedAt ?? uploadedAt;
+    let events = eventsAt(eventTimestamp2);
+    let hash2 = outboundHash(events, identity);
+    if (alreadyUploaded(plan.state, item.ref.harness, item.ref.sessionId, hash2)) continue;
+    if (eventTimestamp2 !== uploadedAt) {
+      eventTimestamp2 = uploadedAt;
+      events = eventsAt(eventTimestamp2);
+      hash2 = outboundHash(events, identity);
+    }
+    items.push({ item, events, hash: hash2 });
+  }
+  return { items, skipped: plan.items.length - items.length };
+}
+async function executeUpload(plan, opts = {}) {
   const uploadedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const { items, skipped } = await prepareOutbound(plan, opts, uploadedAt);
+  const redactionCount = items.reduce((n, { item }) => n + item.redaction.redactionCount, 0);
   if (opts.dryRun) {
-    const allSpans = newItems.flatMap((i) => i.spans);
+    const allSpans = items.flatMap(({ item }) => item.spans);
     const path = await writeOtlpFile(allSpans, opts.otlpOut);
     return {
       uploadedSessions: 0,
@@ -5295,6 +6401,15 @@ async function executeUpload(plan, opts = {}) {
       otlpPath: path
     };
   }
+  if (items.length === 0) {
+    return {
+      uploadedSessions: 0,
+      skippedSessions: skipped,
+      acceptedSpans: 0,
+      redactionCount,
+      dryRun: false
+    };
+  }
   const client = opts.backend ?? hostedClientFromEnv();
   if (!client) {
     throw new Error(
@@ -5303,23 +6418,28 @@ async function executeUpload(plan, opts = {}) {
   }
   const state = plan.state;
   let acceptedSpans = 0;
-  for (const item of newItems) {
-    const meta = await sessionMeta(item, uploadedAt);
-    const events = toTraceSpanEvents(item.spans, meta);
-    const idempotencyKey = `${uploadKey(item.ref.harness, item.ref.sessionId)}:${item.hash}`;
+  const completed = [];
+  for (const outbound of items) {
+    const { item, events, hash: hash2 } = outbound;
+    const key = uploadKey(item.ref.harness, item.ref.sessionId);
+    const idempotencyKey = `${key}:${hash2}`;
     const res = await client.ingestTraces(events, idempotencyKey);
+    if (res.accepted !== events.length) throw new PartialUploadError(key, res.accepted, events.length);
     acceptedSpans += res.accepted;
-    state[uploadKey(item.ref.harness, item.ref.sessionId)] = {
-      hash: item.hash,
+    completed.push({ key, item, hash: hash2, spanCount: events.length });
+    opts.log?.(`uploaded ${item.ref.harness} ${item.ref.sessionId.slice(0, 8)} \u2014 ${res.accepted} spans`);
+  }
+  for (const { key, item, hash: hash2, spanCount } of completed) {
+    state[key] = {
+      hash: hash2,
       uploadedAt,
       harness: item.ref.harness,
-      spanCount: item.spans.length
+      spanCount
     };
-    opts.log?.(`uploaded ${item.ref.harness} ${item.ref.sessionId.slice(0, 8)} \u2014 ${res.accepted} spans`);
   }
   await saveState(state);
   return {
-    uploadedSessions: newItems.length,
+    uploadedSessions: items.length,
     skippedSessions: skipped,
     acceptedSpans,
     redactionCount,
@@ -5328,25 +6448,38 @@ async function executeUpload(plan, opts = {}) {
 }
 
 export {
+  ATTR,
+  INGEST_SOURCE_CLI,
+  DEFAULT_HARNESS,
+  sessionIdFromAttributes,
+  indexSessionIdsByTrace,
+  stampSessionIdentity,
   countSkillRunsJsonl,
   analyzeAdoption,
   span,
   toOpenInferenceSpan,
   serializeSpans,
   writeOtlpFile,
+  summarizeOtlpExecution,
+  summarizeSpanExecution,
   analyzeSpans,
-  ATTR,
-  INGEST_SOURCE_CLI,
-  DEFAULT_HARNESS,
-  parseIsoToEpochMs,
-  parseSince,
-  toRuntimeStore,
-  runPipelines,
   CONTENT_CAP,
   capText,
   ACTOR_ATTR,
   userPromptSpan,
+  parseIsoToEpochMs,
+  parseSince,
+  toRuntimeStore,
+  runPipelines,
+  recordSessionCorruption,
+  sessionIntegrityAttributes,
+  stampSessionIntegrity,
+  JsonSourceError,
+  readJsonFile,
   AmpAdapter,
+  JsonlParseError,
+  readJsonl,
+  takeJsonl,
   textIsSynthetic,
   looksLikeAgentPrompt,
   claudeActor,
@@ -5374,6 +6507,7 @@ export {
   stampRepoAttrs,
   stampSpanWorkdirRepoAttrs,
   parseSession,
+  EmptySessionError,
   locateSessions,
   scanSessions,
   buildPolicyEvidenceRecord,
@@ -5400,6 +6534,7 @@ export {
   writeInspectionReportFile,
   REACTIONS,
   analyzeReactions,
+  CORRUPTION_RECEIPT_DISPLAY_LIMIT,
   summarizeDeterministicSignals,
   renderReport,
   renderPipelines,
@@ -5411,7 +6546,7 @@ export {
   runTraceInvestigation,
   runTraceStoreInvestigation,
   writeTraceImprovementArtifacts,
-  runTraceImprovementLoop,
+  runTraceImprovement,
   saveReport,
   classifyLiveActions,
   defaultTraceLiveAnalysts,
@@ -5427,10 +6562,12 @@ export {
   writeSessionIndexFile,
   uploadKey,
   sessionHash,
+  outboundHash,
   loadState,
   saveState,
   alreadyUploaded,
   planUpload,
   toTraceSpanEvents,
+  PartialUploadError,
   executeUpload
 };