@tangle-network/traces 0.9.5 → 0.9.7

package/dist/{chunk-S4TEBT7Q.js → chunk-NHXPTFKC.js}

@@ -920,10 +920,19 @@ function classifyReaction(text) {
 var CORRECTIVE_REACTIONS = ["correction", "frustration", "jargon", "structure"];
 
 // src/adapters/claude.ts
+import { createHash as createHash4 } from "crypto";
 import { readdir as readdir3, stat as stat2 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { basename as basename2, join as join2 } from "path";
+import { basename as basename2, join as join2, relative } from "path";
+import {
+  applyLlmSpanOtlpAttributes as applyLlmSpanOtlpAttributes2,
+  LLM_CACHED_TOKENS,
+  LLM_CACHE_WRITE_TOKENS,
+  LLM_INPUT_TOKENS,
+  LLM_OUTPUT_TOKENS
+} from "@tangle-network/agent-eval/trace-attributes";
 var SERVICE2 = "claude-code";
+var EPOCH = (/* @__PURE__ */ new Date(0)).toISOString();
 function asBlocks(content) {
   return Array.isArray(content) ? content : [];
 }
@@ -941,61 +950,181 @@ function stringifyToolResult(content) {
   return "";
 }
 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({
+  return {
+    spans: [],
+    toolSpanByUseId: /* @__PURE__ */ new Map(),
+    llmSpanByMessageId: /* @__PURE__ */ new Map(),
+    llmContentByMessageId: /* @__PURE__ */ new Map(),
+    toolCountByMessageId: /* @__PURE__ */ new Map(),
+    step: startStep,
+    sawUserTurn: false
+  };
+}
+var ClaudeEventConflictError = class extends Error {
+  sourcePath;
+  eventId;
+  constructor(sourcePath, eventId) {
+    super(`${sourcePath}: Claude transcript event ${JSON.stringify(eventId)} has conflicting payloads`);
+    this.name = "ClaudeEventConflictError";
+    this.sourcePath = sourcePath;
+    this.eventId = eventId;
+  }
+};
+function projectToolResult(toolUseId, isError, output) {
+  return {
+    toolUseId,
+    isError,
+    attributes: toolIoAttributes({ output }),
+    message: stringifyToolResult(output).slice(0, 500)
+  };
+}
+function projectClaudeEvent(event) {
+  const timestamp = event.timestamp ?? EPOCH;
+  if (event.type === "assistant" && event.message) {
+    const tools = [];
+    for (const block of asBlocks(event.message.content)) {
+      if (block.type !== "tool_use" || !block.name) continue;
+      tools.push({ id: block.id || null, name: block.name, attributes: toolIoAttributes({ input: block.input }) });
+    }
+    return {
+      kind: "assistant",
+      timestamp,
+      messageId: event.message.id ?? null,
+      model: event.message.model ?? null,
+      inputTokens: event.message.usage?.input_tokens ?? null,
+      outputTokens: event.message.usage?.output_tokens ?? null,
+      cachedInputTokens: event.message.usage?.cache_read_input_tokens ?? null,
+      cacheWriteInputTokens: event.message.usage?.cache_creation_input_tokens ?? null,
+      content: textOf2(event.message.content) || null,
+      tools
+    };
+  }
+  if (event.type === "user" && event.message) {
+    const results = [];
+    for (const block of asBlocks(event.message.content)) {
+      if (block.type !== "tool_result" || !block.tool_use_id) continue;
+      results.push(projectToolResult(block.tool_use_id, block.is_error === true, block.content));
+    }
+    const prompt = textOf2(event.message.content);
+    return {
+      kind: "user",
+      timestamp,
+      prompt: prompt || null,
+      ...prompt ? { isSidechain: event.isSidechain === true, userType: event.userType ?? null } : {},
+      results
+    };
+  }
+  if (event.type === "attachment" && event.attachment?.type === "tool_result" && event.attachment.toolUseID) {
+    return {
+      kind: "attachment",
+      timestamp,
+      result: projectToolResult(
+        event.attachment.toolUseID,
+        typeof event.attachment.exitCode === "number" && event.attachment.exitCode !== 0,
+        event.attachment.stderr ?? ""
+      )
+    };
+  }
+  return { kind: "ignored" };
+}
+function fingerprintClaudeEvent(event) {
+  return createHash4("sha256").update(JSON.stringify(event)).digest("hex");
+}
+function consumeDistinctClaudeEvent(event, ctx, state, seen, sourcePath) {
+  const projection = projectClaudeEvent(event);
+  if (event.uuid) {
+    const fingerprint = fingerprintClaudeEvent(projection);
+    const previous = seen.get(event.uuid);
+    if (previous !== void 0) {
+      if (previous !== fingerprint) {
+        throw new ClaudeEventConflictError(sourcePath, event.uuid);
+      }
+      return false;
+    }
+    seen.set(event.uuid, fingerprint);
+  }
+  consumeClaudeEvent(projection, event.uuid ?? `step${state.step}`, ctx, state);
+  return true;
+}
+function consumeClaudeEvent(event, uid, ctx, state) {
+  if (event.kind === "assistant") {
+    const messageId = event.messageId ?? uid;
+    let llmSpan = state.llmSpanByMessageId.get(messageId);
+    if (!llmSpan) {
+      llmSpan = span({
         traceId: ctx.traceId,
-        spanId: llmId,
+        spanId: `${ctx.idPrefix}${uid}`,
         parentSpanId: ctx.rootParent,
         name: "llm.turn",
         kind: "LLM",
-        startTime: ts,
+        startTime: event.timestamp,
         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;
+        model: event.model,
+        inputTokens: event.inputTokens,
+        outputTokens: event.outputTokens,
+        cachedInputTokens: event.cachedInputTokens,
+        cacheWriteInputTokens: event.cacheWriteInputTokens,
+        step: state.step
+      });
+      state.spans.push(llmSpan);
+      state.llmSpanByMessageId.set(messageId, llmSpan);
+      state.step += 1;
+    } else {
+      includeSpanTimestamp(llmSpan, event.timestamp);
+    }
+    applyLlmSpanOtlpAttributes2(llmSpan.attributes, {
+      model: event.model ?? void 0,
+      inputTokens: maxCapturedUsage(
+        llmSpan.attributes[LLM_INPUT_TOKENS],
+        event.inputTokens
+      ),
+      outputTokens: maxCapturedUsage(
+        llmSpan.attributes[LLM_OUTPUT_TOKENS],
+        event.outputTokens
+      ),
+      cachedTokens: maxCapturedUsage(
+        llmSpan.attributes[LLM_CACHED_TOKENS],
+        event.cachedInputTokens
+      ),
+      cacheWriteTokens: maxCapturedUsage(
+        llmSpan.attributes[LLM_CACHE_WRITE_TOKENS],
+        event.cacheWriteInputTokens
+      )
+    });
+    mergeMessageContent(llmSpan, messageId, event.content, state);
+    for (const tool of event.tools) {
+      const existingTool = tool.id ? state.toolSpanByUseId.get(tool.id) : void 0;
+      if (existingTool) {
+        Object.assign(existingTool.attributes, tool.attributes);
+        includeSpanTimestamp(existingTool, event.timestamp);
+        continue;
+      }
+      const toolIdx = state.toolCountByMessageId.get(messageId) ?? 0;
       const toolSpan = span({
         traceId: ctx.traceId,
-        spanId: `${ctx.idPrefix}${uid}:tool:${toolIdx}`,
-        parentSpanId: llmId,
-        name: `tool.${block.name}`,
+        spanId: `${llmSpan.span_id}:tool:${toolIdx}`,
+        parentSpanId: llmSpan.span_id,
+        name: `tool.${tool.name}`,
         kind: "TOOL",
-        startTime: ts,
+        startTime: event.timestamp,
         service: SERVICE2,
         agent: ctx.agent,
-        tool: block.name,
+        tool: tool.name,
         step: state.step,
-        extra: toolIoAttributes({ input: block.input })
+        extra: tool.attributes
       });
       state.spans.push(toolSpan);
-      if (block.id) state.toolSpanByUseId.set(block.id, toolSpan);
-      toolIdx += 1;
+      if (tool.id) state.toolSpanByUseId.set(tool.id, toolSpan);
+      state.toolCountByMessageId.set(messageId, toolIdx + 1);
       state.step += 1;
     }
-  } else if (ev.type === "user" && ev.message) {
-    const prompt = textOf2(ev.message.content);
-    if (prompt) {
+  } else if (event.kind === "user") {
+    if (event.prompt) {
       const actor = claudeActor({
-        text: prompt,
-        isSidechain: ev.isSidechain,
-        userType: ev.userType ?? null,
+        text: event.prompt,
+        isSidechain: event.isSidechain,
+        userType: event.userType ?? null,
         isFirstUserTurn: !state.sawUserTurn
       });
       state.sawUserTurn = true;
@@ -1004,41 +1133,95 @@ function consumeClaudeEvent(ev, ctx, state) {
           traceId: ctx.traceId,
           spanId: `${ctx.idPrefix}${uid}:user`,
           parentSpanId: ctx.rootParent,
-          startTime: ts,
+          startTime: event.timestamp,
           service: SERVICE2,
           agent: ctx.agent,
           step: state.step,
-          content: prompt,
+          content: event.prompt,
           actor
         })
       );
       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
-      );
+    for (const result of event.results) {
+      backfillResult(state.toolSpanByUseId.get(result.toolUseId), event.timestamp, result);
     }
-  } 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 ?? "");
+  } else if (event.kind === "attachment") {
+    backfillResult(state.toolSpanByUseId.get(event.result.toolUseId), event.timestamp, event.result);
   }
 }
+function maxCapturedUsage(current, next) {
+  const captured = typeof current === "number" && Number.isFinite(current) ? current : void 0;
+  if (next == null) return captured;
+  return captured === void 0 ? next : Math.max(captured, next);
+}
+function includeSpanTimestamp(target, timestamp) {
+  if (!timestamp) return;
+  const time = Date.parse(timestamp);
+  if (!Number.isFinite(time)) return;
+  const start = Date.parse(target.start_time);
+  const end = Date.parse(target.end_time);
+  if (!Number.isFinite(start) || time < start) target.start_time = timestamp;
+  if (!Number.isFinite(end) || time > end) target.end_time = timestamp;
+}
+function mergeMessageContent(llmSpan, messageId, content, state) {
+  if (!content) return;
+  const parts = state.llmContentByMessageId.get(messageId) ?? /* @__PURE__ */ new Set();
+  if (parts.has(content)) return;
+  parts.add(content);
+  state.llmContentByMessageId.set(messageId, parts);
+  llmSpan.attributes.content = capText([...parts].join("\n"));
+}
 function finishClaudeStream(state) {
   return { spans: state.spans, toolSpanByUseId: state.toolSpanByUseId, nextStep: state.step };
 }
-function backfillResult(s, endTime, isError, output) {
+function setRootTimeBounds(root, spans) {
+  let firstTimestamp;
+  let lastTimestamp;
+  for (const item of spans) {
+    if (item === root) continue;
+    for (const source of [item.start_time, item.end_time]) {
+      if (!source) continue;
+      const value = Date.parse(source);
+      if (!Number.isFinite(value)) continue;
+      if (!firstTimestamp || value < firstTimestamp.value) firstTimestamp = { value, source };
+      if (!lastTimestamp || value > lastTimestamp.value) lastTimestamp = { value, source };
+    }
+  }
+  if (firstTimestamp) root.start_time = firstTimestamp.source;
+  if (lastTimestamp) root.end_time = lastTimestamp.source;
+}
+function backfillResult(s, endTime, result) {
   if (!s) return;
   s.end_time = endTime;
-  const code = isError ? "ERROR" : "OK";
+  const code = result.isError ? "ERROR" : "OK";
   s.status = { code };
-  recordToolOutput(s, output);
-  const message = stringifyToolResult(output);
-  if (isError && message) s.status.message = message.slice(0, 500);
+  Object.assign(s.attributes, result.attributes);
+  if (result.isError && result.message) s.status.message = result.message;
+}
+async function listSubagentFiles(root) {
+  const pending = [root];
+  const files = [];
+  while (pending.length > 0) {
+    const dir = pending.pop();
+    if (!dir) continue;
+    let entries;
+    try {
+      entries = await readdir3(dir, { withFileTypes: true });
+    } catch (error) {
+      if (isMissingPathError(error)) continue;
+      throw error;
+    }
+    for (const entry of entries) {
+      const path = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        pending.push(path);
+      } else if (entry.isFile() && /^agent-.*\.jsonl$/.test(entry.name)) {
+        files.push(path);
+      }
+    }
+  }
+  return files.sort();
 }
 var ClaudeAdapter = class {
   harness = "claude-code";
@@ -1096,17 +1279,10 @@ var ClaudeAdapter = class {
     };
     const state = createClaudeStream(ctx.startStep);
     let discoveredTraceId;
-    let firstTimestamp;
-    let lastTimestamp;
-    let sawEvent = false;
+    const seen = /* @__PURE__ */ new Map();
     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);
+      if (!consumeDistinctClaudeEvent(event, ctx, state, seen, ref.path)) continue;
     }
     const main = finishClaudeStream(state);
     const traceId = discoveredTraceId ?? sourceTraceId;
@@ -1115,63 +1291,75 @@ var ClaudeAdapter = class {
       item.trace_id = traceId;
       if (item.parent_span_id === sourceRootId) item.parent_span_id = rootId;
     }
-    const spans = [
-      span({
-        traceId,
-        spanId: rootId,
-        parentSpanId: null,
-        name: "session",
-        kind: "AGENT",
-        startTime: firstTimestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-        endTime: lastTimestamp,
-        service: SERVICE2,
-        agent: SERVICE2
-      })
-    ];
+    const root = span({
+      traceId,
+      spanId: rootId,
+      parentSpanId: null,
+      name: "session",
+      kind: "AGENT",
+      startTime: (/* @__PURE__ */ new Date(0)).toISOString(),
+      service: SERVICE2,
+      agent: SERVICE2
+    });
+    const spans = [root];
     appendAll(spans, main.spans);
     await this.foldSubagents(ref, traceId, main, spans, options);
+    setRootTimeBounds(root, spans);
     return spans;
   }
-  /** Parse `<session>/subagents/agent-*.jsonl`, parenting each under its Agent call. */
+  /** Parse nested `subagents/.../agent-*.jsonl`, parenting each under its Agent call. */
   async foldSubagents(ref, traceId, main, out, options) {
     const subDir = join2(ref.path.replace(/\.jsonl$/, ""), "subagents");
-    let files;
-    try {
-      files = await readdir3(subDir);
-    } catch (error) {
-      if (isMissingPathError(error)) return;
-      throw error;
-    }
+    const files = await listSubagentFiles(subDir);
     let step = main.nextStep;
+    const parsedAgents = [];
     for (const file of files) {
-      if (!file.endsWith(".jsonl")) continue;
-      const hash2 = basename2(file, ".jsonl");
-      const metaPath = join2(subDir, `${hash2}.meta.json`);
+      const sourceKey = relative(subDir, file).replace(/\.jsonl$/, "").split(/[\\/]/).map((segment) => encodeURIComponent(segment)).join(":");
+      const metaPath = file.replace(/\.jsonl$/, ".meta.json");
       let meta = {};
       try {
         meta = await readJsonFile(metaPath);
       } catch (error) {
         if (!isMissingJsonSource(error)) throw error;
       }
-      const parent = meta.toolUseId && main.toolSpanByUseId.get(meta.toolUseId)?.span_id || `root:${traceId}`;
       const ctx = {
         traceId,
         agent: meta.agentType ? `subagent:${meta.agentType}` : "subagent",
         startStep: step,
-        idPrefix: `${hash2}:`,
-        rootParent: parent
+        idPrefix: `${sourceKey}:`,
+        rootParent: `root:${traceId}`
       };
       const state = createClaudeStream(ctx.startStep);
+      const seen = /* @__PURE__ */ new Map();
       for await (const event of readJsonl(
-        join2(subDir, file),
+        file,
         sessionJsonlOptions(ref, options)
       )) {
-        consumeClaudeEvent(event, ctx, state);
+        consumeDistinctClaudeEvent(event, ctx, state, seen, file);
       }
       const parsed = finishClaudeStream(state);
-      appendAll(out, parsed.spans);
+      parsedAgents.push({
+        agentId: basename2(file, ".jsonl").replace(/^agent-/, ""),
+        meta,
+        parsed
+      });
       step = parsed.nextStep;
     }
+    const byAgentId = /* @__PURE__ */ new Map();
+    for (const agent of parsedAgents) {
+      if (byAgentId.has(agent.agentId)) {
+        throw new Error(`Duplicate Claude subagent id: ${agent.agentId}`);
+      }
+      byAgentId.set(agent.agentId, agent.parsed);
+    }
+    for (const agent of parsedAgents) {
+      const parentTools = agent.meta.parentAgentId ? byAgentId.get(agent.meta.parentAgentId)?.toolSpanByUseId : main.toolSpanByUseId;
+      const parent = agent.meta.toolUseId && parentTools?.get(agent.meta.toolUseId)?.span_id || `root:${traceId}`;
+      for (const item of agent.parsed.spans) {
+        if (item.parent_span_id === `root:${traceId}`) item.parent_span_id = parent;
+      }
+      appendAll(out, agent.parsed.spans);
+    }
   }
 };
 
@@ -3483,22 +3671,22 @@ async function applyRedactor(spans, redactor) {
 }
 
 // src/file-export.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { mkdtemp as mkdtemp2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join13 } from "path";
 import {
   firstNumberAttr,
   LLM_CACHED_TOKEN_ATTR_KEYS,
-  LLM_CACHED_TOKENS,
+  LLM_CACHED_TOKENS as LLM_CACHED_TOKENS2,
   LLM_CACHE_WRITE_TOKEN_ATTR_KEYS,
-  LLM_CACHE_WRITE_TOKENS,
+  LLM_CACHE_WRITE_TOKENS as LLM_CACHE_WRITE_TOKENS2,
   LLM_COST_ATTR_KEYS,
   LLM_COST_USD,
   LLM_INPUT_TOKEN_ATTR_KEYS,
-  LLM_INPUT_TOKENS,
+  LLM_INPUT_TOKENS as LLM_INPUT_TOKENS2,
   LLM_OUTPUT_TOKEN_ATTR_KEYS,
-  LLM_OUTPUT_TOKENS,
+  LLM_OUTPUT_TOKENS as LLM_OUTPUT_TOKENS2,
   LLM_REASONING_TOKEN_ATTR_KEYS,
   LLM_REASONING_TOKENS
 } from "@tangle-network/agent-eval/trace-attributes";
@@ -3521,7 +3709,7 @@ function stableJson(value) {
   });
 }
 function hashId(value, chars = 16) {
-  return createHash4("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
+  return createHash5("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
 }
 function isoTime(value) {
   if (typeof value === "string") {
@@ -3887,11 +4075,11 @@ var COMPUTED_SPAN_ATTRIBUTES = /* @__PURE__ */ new Set([
   "tool.name",
   "llm.input_tokens",
   "llm.output_tokens",
-  LLM_INPUT_TOKENS,
-  LLM_OUTPUT_TOKENS,
+  LLM_INPUT_TOKENS2,
+  LLM_OUTPUT_TOKENS2,
   LLM_REASONING_TOKENS,
-  LLM_CACHED_TOKENS,
-  LLM_CACHE_WRITE_TOKENS,
+  LLM_CACHED_TOKENS2,
+  LLM_CACHE_WRITE_TOKENS2,
   LLM_COST_USD,
   "step",
   "content"
@@ -5760,7 +5948,7 @@ async function saveReport(path, report) {
 }
 
 // src/live.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } 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;
@@ -5780,7 +5968,7 @@ var sleep = (ms, signal) => new Promise((resolve2) => {
   signal?.addEventListener("abort", onAbort, { once: true });
 });
 function hash(parts) {
-  return createHash5("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
 }
 function asString(value) {
   if (typeof value === "string" && value.trim()) return value;

package/dist/cli.js

@@ -40,7 +40,7 @@ import {
   writePolicyEvidenceFile,
   writeSessionIndexFile,
   writeTraceEvidenceExportFile
-} from "./chunk-S4TEBT7Q.js";
+} from "./chunk-NHXPTFKC.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";

package/dist/index.d.ts

@@ -399,7 +399,7 @@ declare function stampSpanWorkdirRepoAttrs(spans: readonly OtlpSpan[]): Promise<
  * (token trajectory) and `message.content[]` tool_use blocks; tool results
  * arrive as `tool_result` blocks in the following user message or as a
  * `tool_result` attachment. Subagent runs live in a sibling
- * `<session>/subagents/agent-*.jsonl` with a `.meta.json` carrying the
+ * nested `<session>/subagents/.../agent-*.jsonl` files with a `.meta.json` carrying the
  * spawning `toolUseId`, so we parent each subagent under its `Agent` call.
  *
  * Shared by the claudish / openclaw / nanoclaw forks via aliases — they
@@ -412,7 +412,7 @@ declare class ClaudeAdapter implements HarnessTraceAdapter {
     private root;
     locate(opts?: LocateOptions): Promise<SessionRef[]>;
     parse(ref: SessionRef, options?: ParseOptions): Promise<OtlpSpan[]>;
-    /** Parse `<session>/subagents/agent-*.jsonl`, parenting each under its Agent call. */
+    /** Parse nested `subagents/.../agent-*.jsonl`, parenting each under its Agent call. */
     private foldSubagents;
 }
 

package/dist/index.js

@@ -117,7 +117,7 @@ import {
   writeSessionIndexFile,
   writeTraceEvidenceExportFile,
   writeTraceImprovementArtifacts
-} from "./chunk-S4TEBT7Q.js";
+} from "./chunk-NHXPTFKC.js";
 
 // src/collect.ts
 async function collectSessions(opts = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/traces",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "Point it at your coding-agent session traces (Claude Code, Codex, OpenCode, Gemini, Pi, …) and get failure-mode + efficiency findings. CLI + SDK over the @tangle-network/agent-eval analyst suite — observe live sessions, run your own analysts, redact, and upload to the Tangle Intelligence Platform.",
   "type": "module",
   "license": "MIT",