@tangle-network/traces 0.9.4 → 0.9.6

package/dist/{chunk-BKGWYQR4.js → chunk-NP3ZIUR2.js}

@@ -920,10 +920,12 @@ 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";
 var SERVICE2 = "claude-code";
+var EPOCH = (/* @__PURE__ */ new Date(0)).toISOString();
 function asBlocks(content) {
   return Array.isArray(content) ? content : [];
 }
@@ -943,10 +945,93 @@ function stringifyToolResult(content) {
 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) {
+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,
+      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 ?? `${ctx.idPrefix}step${state.step}`, ctx, state);
+  return true;
+}
+function consumeClaudeEvent(event, uid, ctx, state) {
+  if (event.kind === "assistant") {
     const llmId = `${ctx.idPrefix}${uid}`;
     state.spans.push(
       span({
@@ -955,47 +1040,45 @@ function consumeClaudeEvent(ev, ctx, state) {
         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,
+        model: event.model,
+        inputTokens: event.inputTokens,
+        outputTokens: event.outputTokens,
+        cachedInputTokens: event.cachedInputTokens,
+        cacheWriteInputTokens: event.cacheWriteInputTokens,
         step: state.step,
-        content: textOf2(ev.message.content) || null
+        content: event.content
       })
     );
     state.step += 1;
     let toolIdx = 0;
-    for (const block of asBlocks(ev.message.content)) {
-      if (block.type !== "tool_use" || !block.name) continue;
+    for (const tool of event.tools) {
       const toolSpan = span({
         traceId: ctx.traceId,
         spanId: `${ctx.idPrefix}${uid}:tool:${toolIdx}`,
         parentSpanId: llmId,
-        name: `tool.${block.name}`,
+        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);
+      if (tool.id) state.toolSpanByUseId.set(tool.id, toolSpan);
       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 +1087,49 @@ 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 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;
 }
 var ClaudeAdapter = class {
   harness = "claude-code";
@@ -1096,17 +1187,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,21 +1199,20 @@ 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. */
@@ -1162,11 +1245,12 @@ var ClaudeAdapter = class {
         rootParent: parent
       };
       const state = createClaudeStream(ctx.startStep);
+      const seen = /* @__PURE__ */ new Map();
       for await (const event of readJsonl(
         join2(subDir, file),
         sessionJsonlOptions(ref, options)
       )) {
-        consumeClaudeEvent(event, ctx, state);
+        consumeDistinctClaudeEvent(event, ctx, state, seen, join2(subDir, file));
       }
       const parsed = finishClaudeStream(state);
       appendAll(out, parsed.spans);
@@ -3483,7 +3567,7 @@ 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";
@@ -3521,7 +3605,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") {
@@ -4455,9 +4539,9 @@ function skillDocumentNames(s) {
   }
   return [...names];
 }
-function telemetryStatus(measured, unsupported, unknown) {
-  if (measured > 0 && unsupported === 0 && unknown === 0) return "measured";
-  if (measured > 0) return "partial";
+function telemetryStatus(measured2, unsupported, unknown) {
+  if (measured2 > 0 && unsupported === 0 && unknown === 0) return "measured";
+  if (measured2 > 0) return "partial";
   if (unsupported > 0 && unknown === 0) return "unsupported";
   return "unknown";
 }
@@ -4684,6 +4768,12 @@ import {
 } from "@tangle-network/agent-eval/analyst";
 import { OtlpFileTraceStore } from "@tangle-network/agent-eval/traces";
 var GENERATED_TRACE_FILE_CEILING = 512 * 1024 * 1024;
+function mergeCostProvenance(first, second, totalCostUsd) {
+  if (!first || !second || first.kind === "uncaptured" || second.kind === "uncaptured") {
+    return { kind: "uncaptured", usd: null };
+  }
+  return first.kind === "estimated" || second.kind === "estimated" ? { kind: "estimated", usd: totalCostUsd } : { kind: "observed", usd: totalCostUsd };
+}
 async function analyzeSpans(spans, opts = {}) {
   if (spans.length === 0) throw new Error("analyzeSpans: no spans to analyze");
   const otlpPath = await writeOtlpFile(spans, opts.otlpOutPath);
@@ -4716,7 +4806,13 @@ async function analyzeSpans(spans, opts = {}) {
     });
     result.findings.push(...agResult.findings);
     result.per_analyst.push(...agResult.per_analyst);
-    result.total_cost_usd += agResult.total_cost_usd;
+    const totalCostUsd = result.total_cost_usd + agResult.total_cost_usd;
+    result.total_cost_provenance = mergeCostProvenance(
+      result.total_cost_provenance,
+      agResult.total_cost_provenance,
+      totalCostUsd
+    );
+    result.total_cost_usd = totalCostUsd;
   }
   return { otlpPath, execution, result };
 }
@@ -4842,9 +4938,12 @@ function decimal(value, digits = 1) {
     maximumFractionDigits: digits
   });
 }
+function measured(value, render) {
+  return value === null ? "not captured" : render(value);
+}
 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}`;
+  const value = (number) => measured(number, (captured) => `${decimal(captured)}${unit}`);
   return `| ${label} | ${count(distribution.n)} | ${value(distribution.min)} | ${value(distribution.mean)} | ${value(distribution.p50)} | ${value(distribution.p95)} | ${value(distribution.max)} |`;
 }
 function tokenRows(usage) {
@@ -4856,14 +4955,23 @@ function tokenRows(usage) {
     ["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)} |`
+    ([label, total, values]) => `| ${label} | ${count(total)} | ${count(values.n)} | ${measured(values.mean, decimal)} | ${measured(values.p50, decimal)} | ${measured(values.p95, decimal)} | ${measured(values.max, count)} |`
   );
 }
+function analysisCost(result) {
+  const cost = `$${result.total_cost_usd.toFixed(4)}`;
+  if (result.total_cost_provenance?.kind === "observed") return `Analysis cost: ${cost} observed.`;
+  if (result.total_cost_provenance?.kind === "estimated") return `Analysis cost: ${cost} estimated.`;
+  return `Known analysis cost: ${cost}; additional cost was not captured.`;
+}
 function renderExecution(report) {
   const execution = report.execution;
   const lines = ["## execution facts", ""];
   lines.push(
-    `- **Sessions:** ${count(execution.durationMs.n)}  |  **Model-call runs:** ${count(execution.modelCalls.runs)}  |  **Model-call events:** ${count(execution.modelCalls.events)}  |  **Sessions with tool errors:** ${count(execution.failures.runs)}/${count(execution.failures.reportingRuns)} (${decimal(execution.failures.fraction * 100, 2)}%)`
+    `- **Sessions:** ${count(execution.durationMs.n)}  |  **Model-call runs:** ${count(execution.modelCalls.runs)}  |  **Model-call events:** ${count(execution.modelCalls.events)}  |  **Sessions with execution errors:** ${count(execution.executionErrors.runs)}/${count(execution.executionErrors.reportingRuns)} (${measured(execution.executionErrors.fraction, (fraction) => `${decimal(fraction * 100, 2)}%`)})`
+  );
+  lines.push(
+    `- **Terminal outcomes:** ${count(execution.terminalOutcomes.succeeded)} succeeded  |  ${count(execution.terminalOutcomes.failed)} failed  |  ${count(execution.terminalOutcomes.cancelled)} cancelled  |  ${count(execution.terminalOutcomes.incomplete)} incomplete  |  ${count(execution.terminalOutcomes.unknown)} unknown`
   );
   lines.push("- **Task quality:** not measured; these traces do not include comparable task outcome labels.");
   lines.push("");
@@ -4936,7 +5044,7 @@ function renderReport(result, meta) {
   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(
-    `${sessionSummary}, ${meta.spanCount} spans \u2192 **${findingSummary}** across ${result.per_analyst.length} analyst(s). Analysis cost: $${result.total_cost_usd.toFixed(4)}.`
+    `${sessionSummary}, ${meta.spanCount} spans \u2192 **${findingSummary}** across ${result.per_analyst.length} analyst(s). ${analysisCost(result)}`
   );
   lines.push("");
   if (meta.unassignedTraceCount) {
@@ -5736,7 +5844,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;
@@ -5756,7 +5864,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;
@@ -6516,7 +6624,7 @@ async function sessionMeta(item) {
   if (branch) meta[ATTR.GIT_BRANCH] = branch;
   return meta;
 }
-var msToNano = (iso2) => parseIsoToEpochMs(iso2) * 1e6;
+var msToNano = (epochMs) => (BigInt(epochMs) * 1000000n).toString();
 function toTraceSpanEvents(spans, rootMeta) {
   return spans.map((s) => {
     const attributes = {};
@@ -6527,14 +6635,15 @@ function toTraceSpanEvents(spans, rootMeta) {
     attributes[ATTR.SESSION_ID] = s.trace_id;
     attributes[ATTR.INGEST_SOURCE] = INGEST_SOURCE_CLI;
     if (s.parent_span_id === null) Object.assign(attributes, rootMeta);
-    const startNano = msToNano(s.start_time);
+    const startMs = parseIsoToEpochMs(s.start_time);
+    const endMs = Math.max(startMs, parseIsoToEpochMs(s.end_time));
     return {
       traceId: s.trace_id,
       spanId: s.span_id,
       ...s.parent_span_id ? { parentSpanId: s.parent_span_id } : {},
       name: s.name,
-      startTimeUnixNano: startNano,
-      endTimeUnixNano: Math.max(startNano, msToNano(s.end_time)),
+      startTimeUnixNano: msToNano(startMs),
+      endTimeUnixNano: msToNano(endMs),
       attributes,
       ...s.status.code === "UNSET" ? {} : { status: { code: s.status.code, ...s.status.message ? { message: s.status.message } : {} } }
     };

package/dist/cli.js

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

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/traces",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "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",
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@ax-llm/ax": "^23.0.1",
-    "@tangle-network/agent-eval": "^0.124.0"
+    "@tangle-network/agent-eval": "^0.133.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",