@tangle-network/traces 0.1.0 → 0.2.1

package/dist/chunk-YYVPAOOD.js

@@ -0,0 +1,1935 @@
+// src/otlp.ts
+function span(input) {
+  const attributes = {
+    "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.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);
+  const status = { code: input.status ?? "OK" };
+  if (input.statusMessage && input.statusMessage.length > 0) status.message = input.statusMessage;
+  return {
+    trace_id: input.traceId,
+    span_id: input.spanId,
+    parent_span_id: input.parentSpanId ?? null,
+    name: input.name,
+    start_time: input.startTime,
+    end_time: input.endTime ?? input.startTime,
+    status,
+    attributes
+  };
+}
+function serializeSpans(spans) {
+  if (spans.length === 0) return "";
+  return `${spans.map((s) => JSON.stringify(s)).join("\n")}
+`;
+}
+async function writeOtlpFile(spans, outPath) {
+  const { mkdtemp, writeFile: writeFile2 } = await import("fs/promises");
+  const { tmpdir } = await import("os");
+  const { join: join13 } = await import("path");
+  const path = outPath ?? join13(await mkdtemp(join13(tmpdir(), "traces-")), "spans.otlp.jsonl");
+  await writeFile2(path, serializeSpans(spans), "utf8");
+  return path;
+}
+
+// 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;
+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 });
+  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 });
+    await agStore.ensureIndexed();
+    const agRegistry = buildDefaultAnalystRegistry({
+      ai: opts.ai,
+      model: opts.model,
+      includeBehavioral: false,
+      registry: { log: opts.log }
+    });
+    const agResult = await agRegistry.run(runId, { traceStore: agStore }, {
+      budget: opts.budgetUsd != null ? { totalUsd: opts.budgetUsd } : void 0
+    });
+    result.findings.push(...agResult.findings);
+    result.per_analyst.push(...agResult.per_analyst);
+    result.total_cost_usd += agResult.total_cost_usd;
+  }
+  return { otlpPath, result };
+}
+
+// src/runtime-store.ts
+import { InMemoryTraceStore } from "@tangle-network/agent-eval";
+var KIND = {
+  AGENT: "agent",
+  LLM: "llm",
+  TOOL: "tool",
+  CHAIN: "custom",
+  SPAN: "custom"
+};
+function ms(iso2) {
+  const n = Date.parse(iso2);
+  return Number.isNaN(n) ? 0 : n;
+}
+async function toRuntimeStore(spans) {
+  const store = new InMemoryTraceStore();
+  const runIds = /* @__PURE__ */ new Set();
+  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 base = {
+      spanId: s.span_id,
+      parentSpanId: s.parent_span_id ?? void 0,
+      runId: s.trace_id,
+      name: s.name,
+      startedAt: ms(s.start_time),
+      endedAt: ms(s.end_time),
+      status: s.status.code === "ERROR" ? "error" : "ok",
+      error: s.status.message,
+      attributes: s.attributes
+    };
+    const span2 = kind === "tool" ? {
+      ...base,
+      kind: "tool",
+      toolName: String(s.attributes["tool.name"] ?? "tool"),
+      args: s.attributes.content ?? ""
+    } : { ...base, kind };
+    await store.appendSpan(span2);
+  }
+  return { store, runIds: [...runIds] };
+}
+
+// src/pipelines.ts
+import { computeToolUseMetrics } from "@tangle-network/agent-eval";
+import { stuckLoopView } from "@tangle-network/agent-eval/pipelines";
+async function runPipelines(spans, opts = {}) {
+  const { store, runIds } = await toRuntimeStore(spans);
+  const stuckLoops = await stuckLoopView(store, { minOccurrences: opts.minLoopOccurrences ?? 3 });
+  const toolUse = await Promise.all(runIds.map((runId) => computeToolUseMetrics(store, runId)));
+  return { stuckLoops, toolUse };
+}
+
+// src/adapters/amp.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { homedir } from "os";
+import { basename, join } from "path";
+var SERVICE = "amp";
+var AmpAdapter = class {
+  harness = "amp";
+  threadsRoot() {
+    const base = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+    return join(base, "amp", "threads");
+  }
+  async locate(opts = {}) {
+    let files;
+    try {
+      files = await readdir(this.threadsRoot());
+    } catch {
+      return [];
+    }
+    const refs = [];
+    for (const f of files) {
+      if (!f.startsWith("T-") || !f.endsWith(".json")) continue;
+      const path = join(this.threadsRoot(), f);
+      let st;
+      try {
+        st = await stat(path);
+      } catch {
+        continue;
+      }
+      if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
+      if (opts.cwd) continue;
+      refs.push({ harness: this.harness, sessionId: basename(f, ".json"), path, cwd: null, mtimeMs: st.mtimeMs });
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }
+  async parse(ref) {
+    let thread;
+    try {
+      thread = JSON.parse(await readFile(ref.path, "utf8"));
+    } catch {
+      return [];
+    }
+    const traceId = thread.id ?? ref.sessionId;
+    const rootId = `root:${traceId}`;
+    const start = new Date(thread.created ?? 0).toISOString();
+    const messages = thread.messages ?? [];
+    const spans = [
+      span({ traceId, spanId: rootId, parentSpanId: null, name: "session", kind: "AGENT", startTime: start, service: SERVICE, agent: SERVICE })
+    ];
+    const toolByUseId = /* @__PURE__ */ new Map();
+    let step = 0;
+    for (const m of messages) {
+      const mid = m.messageId ?? step;
+      const llmId = `llm:${mid}`;
+      const u = m.usage;
+      const inputTokens2 = u ? (u.inputTokens ?? 0) + (u.cacheReadInputTokens ?? 0) + (u.cacheCreationInputTokens ?? 0) || null : null;
+      spans.push(
+        span({
+          traceId,
+          spanId: llmId,
+          parentSpanId: rootId,
+          name: `message.${m.role ?? "unknown"}`,
+          kind: "LLM",
+          startTime: start,
+          service: SERVICE,
+          agent: SERVICE,
+          model: u?.model ?? null,
+          inputTokens: inputTokens2,
+          outputTokens: u?.outputTokens ?? null,
+          step
+        })
+      );
+      step += 1;
+      for (const b of m.content ?? []) {
+        if (b.type === "tool_use" && b.name) {
+          const t = span({
+            traceId,
+            spanId: `tool:${b.id ?? `${mid}:${step}`}`,
+            parentSpanId: llmId,
+            name: `tool.${b.name}`,
+            kind: "TOOL",
+            startTime: start,
+            service: SERVICE,
+            agent: SERVICE,
+            tool: b.name,
+            step,
+            content: b.input != null ? JSON.stringify(b.input) : null
+          });
+          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" };
+        }
+      }
+    }
+    return spans;
+  }
+};
+
+// src/adapters/claude.ts
+import { readdir as readdir2, readFile as readFile2, 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";
+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 : [];
+}
+function stringifyToolResult(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => c && typeof c === "object" && "text" in c ? String(c.text ?? "") : "").join("");
+  }
+  return "";
+}
+function parseClaudeStream(events, ctx) {
+  const spans = [];
+  const toolSpanByUseId = /* @__PURE__ */ new Map();
+  let step = ctx.startStep;
+  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({
+          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: inputTokens(ev.message.usage),
+          outputTokens: ev.message.usage?.output_tokens ?? null,
+          step
+        })
+      );
+      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) {
+      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 ?? "");
+    }
+  }
+  return { spans, toolSpanByUseId, nextStep: step };
+}
+function backfillResult(s, endTime, isError, message) {
+  if (!s) return;
+  s.end_time = endTime;
+  const code = isError ? "ERROR" : "OK";
+  s.status = { code };
+  if (isError && message) s.status.message = message.slice(0, 500);
+}
+var ClaudeAdapter = class {
+  harness = "claude-code";
+  aliases = ["claude", "claudish", "openclaw", "nanoclaw"];
+  root() {
+    return join2(homedir2(), ".claude", "projects");
+  }
+  async locate(opts = {}) {
+    const root = this.root();
+    let projectDirs;
+    try {
+      projectDirs = await readdir2(root);
+    } catch {
+      return [];
+    }
+    const refs = [];
+    for (const dir of projectDirs) {
+      const dirPath = join2(root, dir);
+      let files;
+      try {
+        files = await readdir2(dirPath);
+      } catch {
+        continue;
+      }
+      for (const f of files) {
+        if (!f.endsWith(".jsonl")) continue;
+        const path = join2(dirPath, f);
+        let st;
+        try {
+          st = await stat2(path);
+        } catch {
+          continue;
+        }
+        if (!st.isFile()) continue;
+        if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
+        const cwd = `/${dir.replace(/^-/, "").replace(/-/g, "/")}`;
+        if (opts.cwd && !cwd.startsWith(opts.cwd)) continue;
+        refs.push({ harness: this.harness, sessionId: basename2(f, ".jsonl"), path, cwd, mtimeMs: st.mtimeMs });
+      }
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }
+  async parse(ref) {
+    const raw = await readFile2(ref.path, "utf8");
+    const events = parseLines(raw);
+    const traceId = events.find((e) => e.sessionId)?.sessionId ?? 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: SERVICE2,
+        agent: SERVICE2
+      })
+    ];
+    const main = parseClaudeStream(events, {
+      traceId,
+      agent: SERVICE2,
+      startStep: 0,
+      idPrefix: "",
+      rootParent: rootId
+    });
+    spans.push(...main.spans);
+    await this.foldSubagents(ref, traceId, main, spans);
+    return spans;
+  }
+  /** Parse `<session>/subagents/agent-*.jsonl`, parenting each under its Agent call. */
+  async foldSubagents(ref, traceId, main, out) {
+    const subDir = join2(ref.path.replace(/\.jsonl$/, ""), "subagents");
+    let files;
+    try {
+      files = await readdir2(subDir);
+    } catch {
+      return;
+    }
+    let step = main.nextStep;
+    for (const f of files) {
+      if (!f.endsWith(".jsonl")) continue;
+      const hash = basename2(f, ".jsonl");
+      let meta = {};
+      try {
+        meta = JSON.parse(await readFile2(join2(subDir, `${hash}.meta.json`), "utf8"));
+      } catch {
+      }
+      const parent = meta.toolUseId && main.toolSpanByUseId.get(meta.toolUseId)?.span_id || `root:${traceId}`;
+      let raw;
+      try {
+        raw = await readFile2(join2(subDir, f), "utf8");
+      } catch {
+        continue;
+      }
+      const parsed = parseClaudeStream(parseLines(raw), {
+        traceId,
+        agent: meta.agentType ? `subagent:${meta.agentType}` : "subagent",
+        startStep: step,
+        idPrefix: `${hash}:`,
+        rootParent: parent
+      });
+      out.push(...parsed.spans);
+      step = parsed.nextStep;
+    }
+  }
+};
+
+// src/adapters/codex.ts
+import { readdir as readdir3, readFile as readFile3, stat as stat3 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { basename as basename3, join as join3 } 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;
+}
+function contentToString(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => c && typeof c === "object" && "text" in c ? String(c.text ?? "") : "").join("");
+  }
+  return "";
+}
+function outputIsError(output) {
+  const s = typeof output === "string" ? output : JSON.stringify(output ?? "");
+  const error = /"success"\s*:\s*false|exit(?:_| )code["\s:]+[1-9]|\bcommand failed\b|\bENOENT\b|\berror:/i.test(s);
+  return { error, message: error ? s.slice(0, 500) : "" };
+}
+async function* walkRollouts(root) {
+  let years;
+  try {
+    years = await readdir3(root);
+  } catch {
+    return;
+  }
+  for (const y of years) {
+    const yp = join3(root, y);
+    let months;
+    try {
+      months = await readdir3(yp);
+    } catch {
+      continue;
+    }
+    for (const m of months) {
+      const mp = join3(yp, m);
+      let days;
+      try {
+        days = await readdir3(mp);
+      } catch {
+        continue;
+      }
+      for (const d of days) {
+        const dp = join3(mp, d);
+        let files;
+        try {
+          files = await readdir3(dp);
+        } catch {
+          continue;
+        }
+        for (const f of files) {
+          if (f.startsWith("rollout-") && f.endsWith(".jsonl")) yield join3(dp, f);
+        }
+      }
+    }
+  }
+}
+var CodexAdapter = class {
+  harness = "codex";
+  aliases = ["codex-acp"];
+  root() {
+    return process.env.CODEX_HOME ? join3(process.env.CODEX_HOME, "sessions") : join3(homedir3(), ".codex", "sessions");
+  }
+  async locate(opts = {}) {
+    const refs = [];
+    for await (const path of walkRollouts(this.root())) {
+      let st;
+      try {
+        st = await stat3(path);
+      } catch {
+        continue;
+      }
+      if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
+      const head = (await readFile3(path, "utf8").catch(() => "")).split("\n", 1)[0] ?? "";
+      let cwd = null;
+      let id = basename3(path).replace(/^rollout-[\dT-]+-/, "").replace(/\.jsonl$/, "");
+      try {
+        const meta = JSON.parse(head);
+        if (meta.payload?.cwd) cwd = meta.payload.cwd;
+        if (meta.payload?.id) id = meta.payload.id;
+      } catch {
+      }
+      if (opts.cwd && (!cwd || !cwd.startsWith(opts.cwd))) continue;
+      refs.push({ harness: this.harness, sessionId: id, path, cwd, mtimeMs: st.mtimeMs });
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }
+  async parse(ref) {
+    const lines = parseLines2(await readFile3(ref.path, "utf8"));
+    const meta = lines.find((l) => l.type === "session_meta");
+    const traceId = meta?.payload?.id ?? ref.sessionId;
+    const model = lines.find((l) => l.type === "turn_context")?.payload?.model ?? null;
+    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 toolByCallId = /* @__PURE__ */ new Map();
+    let step = 0;
+    let lastLlm = rootId;
+    for (const l of lines) {
+      const ts = l.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
+      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
+            })
+          );
+          lastLlm = id;
+          step += 1;
+        }
+      } else if (l.type === "response_item" && l.payload?.type === "function_call") {
+        const name = l.payload.name ?? "tool";
+        const callId = l.payload.call_id ?? `${step}`;
+        const toolSpan = span({
+          traceId,
+          spanId: `tool:${callId}`,
+          parentSpanId: lastLlm,
+          name: `tool.${name}`,
+          kind: "TOOL",
+          startTime: ts,
+          service: SERVICE3,
+          agent: SERVICE3,
+          tool: name,
+          step,
+          content: l.payload.arguments ?? null
+        });
+        spans.push(toolSpan);
+        toolByCallId.set(callId, toolSpan);
+        step += 1;
+      } else if (l.type === "response_item" && l.payload?.type === "function_call_output") {
+        const t = toolByCallId.get(l.payload.call_id ?? "");
+        if (t) {
+          const { error, message } = outputIsError(l.payload.output);
+          t.end_time = ts;
+          t.status = error ? { code: "ERROR", message } : { code: "OK" };
+        }
+      } else if (l.type === "response_item" && l.payload?.type === "message") {
+        const text = contentToString(l.payload.content);
+        if (text) {
+          spans.push(
+            span({
+              traceId,
+              spanId: `msg:${step}`,
+              parentSpanId: rootId,
+              name: `message.${l.payload.role ?? "unknown"}`,
+              kind: "CHAIN",
+              startTime: ts,
+              service: SERVICE3,
+              agent: SERVICE3,
+              step,
+              content: text.slice(0, 8e3)
+            })
+          );
+          step += 1;
+        }
+      }
+    }
+    return spans;
+  }
+};
+
+// src/adapters/copilot.ts
+import { readdir as readdir4, readFile as readFile4, stat as stat4 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join4 } 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"];
+  root() {
+    return join4(process.env.COPILOT_HOME ?? join4(homedir4(), ".copilot"), "session-state");
+  }
+  async locate(opts = {}) {
+    let dirs;
+    try {
+      dirs = await readdir4(this.root());
+    } catch {
+      return [];
+    }
+    const refs = [];
+    for (const id of dirs) {
+      const path = join4(this.root(), id, "events.jsonl");
+      let st;
+      try {
+        st = await stat4(path);
+      } catch {
+        continue;
+      }
+      if (!st.isFile()) continue;
+      if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
+      if (opts.cwd) continue;
+      refs.push({ harness: this.harness, sessionId: id, path, cwd: null, mtimeMs: st.mtimeMs });
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }
+  async parse(ref) {
+    const events = parseLines3(await readFile4(ref.path, "utf8"));
+    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 toolByCallId = /* @__PURE__ */ new Map();
+    let step = 0;
+    let lastLlm = rootId;
+    let pendingInputTokens = null;
+    for (const ev of events) {
+      const ts = ev.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
+      const d = ev.data ?? {};
+      if (ev.type === "assistant.usage") {
+        pendingInputTokens = d.inputTokens ?? null;
+        continue;
+      }
+      if (ev.type === "assistant.message") {
+        const llmId = `llm:${d.messageId ?? ev.id ?? step}`;
+        spans.push(
+          span({
+            traceId,
+            spanId: llmId,
+            parentSpanId: rootId,
+            name: "message.assistant",
+            kind: "LLM",
+            startTime: ts,
+            service: SERVICE4,
+            agent: SERVICE4,
+            model: d.model ?? null,
+            inputTokens: pendingInputTokens,
+            outputTokens: d.outputTokens ?? null,
+            step,
+            content: typeof d.content === "string" ? d.content.slice(0, 8e3) : null
+          })
+        );
+        lastLlm = llmId;
+        pendingInputTokens = null;
+        step += 1;
+      } else if (ev.type === "tool.execution_start" && d.toolCallId) {
+        const name = d.toolName ?? "tool";
+        const t = span({
+          traceId,
+          spanId: `tool:${d.toolCallId}`,
+          parentSpanId: lastLlm,
+          name: `tool.${name}`,
+          kind: "TOOL",
+          startTime: ts,
+          service: SERVICE4,
+          agent: SERVICE4,
+          tool: name,
+          step,
+          content: d.arguments != null ? JSON.stringify(d.arguments) : null
+        });
+        spans.push(t);
+        toolByCallId.set(d.toolCallId, t);
+        step += 1;
+      } else if (ev.type === "tool.execution_complete" && d.toolCallId) {
+        const t = toolByCallId.get(d.toolCallId);
+        if (t) {
+          t.end_time = ts;
+          const err = d.success === false;
+          t.status = err ? { code: "ERROR", message: (d.error?.message ?? "").slice(0, 500) } : { code: "OK" };
+        }
+      }
+    }
+    return spans;
+  }
+};
+
+// src/adapters/factory.ts
+import { readdir as readdir5, readFile as readFile5, stat as stat5 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { basename as basename4, join as join5 } from "path";
+var SERVICE5 = "factory";
+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"];
+  root() {
+    return join5(homedir5(), ".factory", "sessions");
+  }
+  async locate(opts = {}) {
+    const root = this.root();
+    let dirs;
+    try {
+      dirs = await readdir5(root);
+    } catch {
+      return [];
+    }
+    const refs = [];
+    for (const dir of dirs) {
+      const dp = join5(root, dir);
+      let files;
+      try {
+        files = await readdir5(dp);
+      } catch {
+        continue;
+      }
+      const cwd = dir.replace(/-/g, "/");
+      if (opts.cwd && !cwd.startsWith(opts.cwd)) continue;
+      for (const f of files) {
+        if (!f.endsWith(".jsonl")) continue;
+        const path = join5(dp, f);
+        let st;
+        try {
+          st = await stat5(path);
+        } catch {
+          continue;
+        }
+        if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
+        refs.push({ harness: this.harness, sessionId: basename4(f, ".jsonl"), path, cwd, mtimeMs: st.mtimeMs });
+      }
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }
+  async parse(ref) {
+    const lines = parseLines4(await readFile5(ref.path, "utf8"));
+    const start = lines.find((l) => l.type === "session_start");
+    const traceId = start?.id ?? ref.sessionId;
+    const rootId = `root:${traceId}`;
+    let settings = {};
+    try {
+      settings = JSON.parse(await readFile5(ref.path.replace(/\.jsonl$/, ".settings.json"), "utf8"));
+    } catch {
+    }
+    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 toolByUseId = /* @__PURE__ */ new Map();
+    let step = 0;
+    let lastLlm = rootId;
+    for (const l of lines) {
+      if (l.type !== "message" || !l.message) continue;
+      const ts = l.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
+      const role = l.message.role;
+      const llmId = `llm:${l.id ?? step}`;
+      const text = (l.message.content ?? []).filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+      spans.push(
+        span({
+          traceId,
+          spanId: llmId,
+          parentSpanId: rootId,
+          name: `message.${role ?? "unknown"}`,
+          kind: "LLM",
+          startTime: ts,
+          service: SERVICE5,
+          agent: SERVICE5,
+          model: settings.model ?? null,
+          step,
+          content: text ? text.slice(0, 8e3) : null
+        })
+      );
+      lastLlm = llmId;
+      step += 1;
+      for (const b of l.message.content ?? []) {
+        if (b.type === "tool_use" && b.name) {
+          const t = span({
+            traceId,
+            spanId: `tool:${b.id ?? `${l.id}:${step}`}`,
+            parentSpanId: lastLlm,
+            name: `tool.${b.name}`,
+            kind: "TOOL",
+            startTime: ts,
+            service: SERVICE5,
+            agent: SERVICE5,
+            tool: b.name,
+            step,
+            content: b.input != null ? JSON.stringify(b.input) : null
+          });
+          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" };
+        }
+      }
+    }
+    return spans;
+  }
+};
+
+// src/adapters/forge.ts
+import { readdir as readdir6, readFile as readFile6, stat as stat6 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { basename as basename5, join as join6 } from "path";
+var SERVICE6 = "forge";
+function tokens(t) {
+  if (!t) return null;
+  return t.actual ?? t.approx ?? null;
+}
+var ForgeAdapter = class {
+  harness = "forge";
+  aliases = ["forgecode"];
+  /** Directories scanned for `*-dump.json` exports. */
+  dumpDirs() {
+    return [process.cwd(), join6(homedir6(), ".forge")];
+  }
+  async locate(opts = {}) {
+    const refs = [];
+    const dirs = opts.cwd ? [opts.cwd] : this.dumpDirs();
+    for (const dir of dirs) {
+      let files;
+      try {
+        files = await readdir6(dir);
+      } catch {
+        continue;
+      }
+      for (const f of files) {
+        if (!f.endsWith("-dump.json")) continue;
+        const path = join6(dir, f);
+        let st;
+        try {
+          st = await stat6(path);
+        } catch {
+          continue;
+        }
+        if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
+        refs.push({ harness: this.harness, sessionId: basename5(f, ".json"), path, cwd: dir, mtimeMs: st.mtimeMs });
+      }
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }
+  async parse(ref) {
+    let dump;
+    try {
+      dump = JSON.parse(await readFile6(ref.path, "utf8"));
+    } catch {
+      return [];
+    }
+    const ctx = dump.context ?? dump;
+    const traceId = ctx.conversation_id ?? ref.sessionId;
+    const rootId = `root:${traceId}`;
+    const messages = ctx.messages ?? [];
+    const spans = [
+      span({ traceId, spanId: rootId, parentSpanId: null, name: "session", kind: "AGENT", startTime: (/* @__PURE__ */ new Date(0)).toISOString(), service: SERVICE6, agent: SERVICE6 })
+    ];
+    const toolByCallId = /* @__PURE__ */ new Map();
+    let step = 0;
+    let lastLlm = rootId;
+    for (const raw of messages) {
+      const entry = raw.message ?? raw;
+      const ts = (/* @__PURE__ */ new Date(0)).toISOString();
+      if (entry.text) {
+        const llmId = `llm:${step}`;
+        spans.push(
+          span({
+            traceId,
+            spanId: llmId,
+            parentSpanId: rootId,
+            name: `message.${entry.text.role ?? "unknown"}`,
+            kind: "LLM",
+            startTime: ts,
+            service: SERVICE6,
+            agent: SERVICE6,
+            model: entry.text.model ?? null,
+            inputTokens: tokens(raw.usage?.prompt_tokens),
+            outputTokens: tokens(raw.usage?.completion_tokens),
+            step,
+            content: entry.text.content ? entry.text.content.slice(0, 8e3) : null
+          })
+        );
+        lastLlm = llmId;
+        step += 1;
+        for (const tc of entry.text.tool_calls ?? []) {
+          const id = tc.call_id ?? `${step}`;
+          const t = span({
+            traceId,
+            spanId: `tool:${id}`,
+            parentSpanId: llmId,
+            name: `tool.${tc.name ?? "tool"}`,
+            kind: "TOOL",
+            startTime: ts,
+            service: SERVICE6,
+            agent: SERVICE6,
+            tool: tc.name ?? "tool",
+            step,
+            content: tc.arguments != null ? JSON.stringify(tc.arguments) : null
+          });
+          spans.push(t);
+          toolByCallId.set(id, t);
+          step += 1;
+        }
+      } 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" };
+      }
+    }
+    return spans;
+  }
+};
+
+// src/adapters/gemini.ts
+import { readdir as readdir7, readFile as readFile7, stat as stat7 } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join7 } from "path";
+function iso(ts, fallback) {
+  if (typeof ts === "number") return new Date(ts).toISOString();
+  if (typeof ts === "string" && ts.length > 0) return ts;
+  return fallback;
+}
+function toolStatusError(status) {
+  return status != null && /error|fail|cancel/i.test(status);
+}
+var GeminiFamilyAdapter = class {
+  harness;
+  aliases;
+  service;
+  homeDirName;
+  constructor(cfg) {
+    this.harness = cfg.harness;
+    this.aliases = cfg.aliases;
+    this.service = cfg.service;
+    this.homeDirName = cfg.homeDirName;
+  }
+  chatsRoot() {
+    return join7(homedir7(), this.homeDirName, "tmp");
+  }
+  async locate(opts = {}) {
+    const root = this.chatsRoot();
+    let projectDirs;
+    try {
+      projectDirs = await readdir7(root);
+    } catch {
+      return [];
+    }
+    const refs = [];
+    for (const pd of projectDirs) {
+      const chatsDir = join7(root, pd, "chats");
+      let files;
+      try {
+        files = await readdir7(chatsDir);
+      } catch {
+        continue;
+      }
+      for (const f of files) {
+        if (!f.startsWith("session-") || !f.endsWith(".json")) continue;
+        const path = join7(chatsDir, f);
+        let st;
+        try {
+          st = await stat7(path);
+        } catch {
+          continue;
+        }
+        if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
+        if (opts.cwd) continue;
+        refs.push({ harness: this.harness, sessionId: f.replace(/\.json$/, ""), path, cwd: null, mtimeMs: st.mtimeMs });
+      }
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }
+  async parse(ref) {
+    let session;
+    try {
+      session = JSON.parse(await readFile7(ref.path, "utf8"));
+    } catch {
+      return [];
+    }
+    const traceId = session.sessionId ?? ref.sessionId;
+    const messages = session.messages ?? [];
+    const rootId = `root:${traceId}`;
+    const start = iso(session.startTime ?? messages[0]?.timestamp, (/* @__PURE__ */ new Date(0)).toISOString());
+    const spans = [
+      span({
+        traceId,
+        spanId: rootId,
+        parentSpanId: null,
+        name: "session",
+        kind: "AGENT",
+        startTime: start,
+        endTime: iso(messages.at(-1)?.timestamp, start),
+        service: this.service,
+        agent: this.service
+      })
+    ];
+    let step = 0;
+    for (const m of messages) {
+      const mid = m.id ?? `m${step}`;
+      const ts = iso(m.timestamp, start);
+      const llmId = `llm:${mid}`;
+      const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content ?? "");
+      spans.push(
+        span({
+          traceId,
+          spanId: llmId,
+          parentSpanId: rootId,
+          name: `message.${m.type ?? "unknown"}`,
+          kind: "LLM",
+          startTime: ts,
+          service: this.service,
+          agent: this.service,
+          model: m.model ?? null,
+          inputTokens: m.tokens?.input ?? null,
+          outputTokens: m.tokens?.output ?? null,
+          step,
+          content: content ? content.slice(0, 8e3) : null
+        })
+      );
+      step += 1;
+      for (const tc of m.toolCalls ?? []) {
+        const err = toolStatusError(tc.status);
+        spans.push(
+          span({
+            traceId,
+            spanId: `tool:${tc.id ?? `${mid}:${step}`}`,
+            parentSpanId: llmId,
+            name: `tool.${tc.name ?? "tool"}`,
+            kind: "TOOL",
+            startTime: ts,
+            status: err ? "ERROR" : "OK",
+            statusMessage: err ? `status=${tc.status}` : void 0,
+            service: this.service,
+            agent: this.service,
+            tool: tc.name ?? "tool",
+            step,
+            content: tc.args != null ? JSON.stringify(tc.args) : null
+          })
+        );
+        step += 1;
+      }
+    }
+    return spans;
+  }
+};
+var GeminiAdapter = class extends GeminiFamilyAdapter {
+  constructor() {
+    super({ harness: "gemini", service: "gemini", homeDirName: ".gemini", aliases: ["gemini-cli"] });
+  }
+};
+
+// src/adapters/opencode.ts
+import { readdir as readdir8, readFile as readFile8, stat as stat8 } from "fs/promises";
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
+var SERVICE7 = "opencode";
+function isoOf(ms2) {
+  return new Date(ms2 ?? 0).toISOString();
+}
+var OpencodeAdapter = class {
+  harness = "opencode";
+  storage() {
+    const base = process.env.XDG_DATA_HOME ?? join8(homedir8(), ".local", "share");
+    return join8(base, "opencode", "storage");
+  }
+  async locate(opts = {}) {
+    const msgRoot = join8(this.storage(), "message");
+    let sessionDirs;
+    try {
+      sessionDirs = await readdir8(msgRoot);
+    } catch {
+      return [];
+    }
+    const refs = [];
+    for (const sid of sessionDirs) {
+      const dir = join8(msgRoot, sid);
+      let st;
+      try {
+        st = await stat8(dir);
+      } catch {
+        continue;
+      }
+      if (!st.isDirectory()) continue;
+      if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
+      if (opts.cwd) continue;
+      refs.push({ harness: this.harness, sessionId: sid, path: dir, cwd: null, mtimeMs: st.mtimeMs });
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }
+  async parse(ref) {
+    const traceId = ref.sessionId;
+    const rootId = `root:${traceId}`;
+    const partRoot = join8(this.storage(), "part");
+    let msgFiles;
+    try {
+      msgFiles = (await readdir8(ref.path)).filter((f) => f.endsWith(".json"));
+    } catch {
+      return [];
+    }
+    const messages = [];
+    for (const f of msgFiles) {
+      try {
+        messages.push({ msg: JSON.parse(await readFile8(join8(ref.path, f), "utf8")), file: f });
+      } catch {
+      }
+    }
+    messages.sort((a, b) => (a.msg.time?.created ?? 0) - (b.msg.time?.created ?? 0));
+    const spans = [
+      span({
+        traceId,
+        spanId: rootId,
+        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),
+        service: SERVICE7,
+        agent: SERVICE7
+      })
+    ];
+    let step = 0;
+    for (const { msg } of messages) {
+      const mid = msg.id ?? `m${step}`;
+      const llmId = `llm:${mid}`;
+      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
+        })
+      );
+      step += 1;
+      const pdir = join8(partRoot, mid);
+      let partFiles;
+      try {
+        partFiles = (await readdir8(pdir)).filter((f) => f.endsWith(".json"));
+      } catch {
+        continue;
+      }
+      for (const pf of partFiles) {
+        let part;
+        try {
+          part = JSON.parse(await readFile8(join8(pdir, pf), "utf8"));
+        } catch {
+          continue;
+        }
+        if (part.type !== "tool" || !part.tool) continue;
+        const err = part.state?.status === "error";
+        spans.push(
+          span({
+            traceId,
+            spanId: `tool:${part.callID ?? `${mid}:${step}`}`,
+            parentSpanId: llmId,
+            name: `tool.${part.tool}`,
+            kind: "TOOL",
+            startTime: isoOf(msg.time?.created),
+            endTime: isoOf(msg.time?.completed ?? msg.time?.created),
+            status: err ? "ERROR" : "OK",
+            statusMessage: err ? (part.state?.error ?? "").slice(0, 500) : void 0,
+            service: SERVICE7,
+            agent: SERVICE7,
+            tool: part.tool,
+            step,
+            content: part.state?.input != null ? JSON.stringify(part.state.input) : null
+          })
+        );
+        step += 1;
+      }
+    }
+    return spans;
+  }
+};
+
+// src/adapters/pi.ts
+import { readdir as readdir9, readFile as readFile9, stat as stat9 } from "fs/promises";
+import { homedir as homedir9 } from "os";
+import { basename as basename6, join as join9 } 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);
+}
+function isToolResultBlock(b) {
+  return typeof b.type === "string" && /tool[_-]?result|tool[_-]?output/i.test(b.type);
+}
+function textOf(content) {
+  if (!content) return "";
+  return content.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+}
+var PiAdapter = class {
+  harness = "pi";
+  root() {
+    return join9(homedir9(), ".pi", "agent", "sessions");
+  }
+  async locate(opts = {}) {
+    const root = this.root();
+    let dirs;
+    try {
+      dirs = await readdir9(root);
+    } catch {
+      return [];
+    }
+    const refs = [];
+    for (const dir of dirs) {
+      const dp = join9(root, dir);
+      let files;
+      try {
+        files = await readdir9(dp);
+      } catch {
+        continue;
+      }
+      const cwd = `/${dir.replace(/^-+/, "").replace(/-+$/, "").replace(/-/g, "/")}`;
+      if (opts.cwd && !cwd.startsWith(opts.cwd)) continue;
+      for (const f of files) {
+        if (!f.endsWith(".jsonl")) continue;
+        const path = join9(dp, f);
+        let st;
+        try {
+          st = await stat9(path);
+        } catch {
+          continue;
+        }
+        if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
+        const id = basename6(f, ".jsonl").replace(/^[\dTZ.-]+_/, "");
+        refs.push({ harness: this.harness, sessionId: id, path, cwd, mtimeMs: st.mtimeMs });
+      }
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }
+  async parse(ref) {
+    const lines = parseLines5(await readFile9(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
+      })
+    ];
+    const toolByCallId = /* @__PURE__ */ new Map();
+    let step = 0;
+    for (const l of lines) {
+      if (l.type !== "message" || !l.message) continue;
+      const ts = l.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
+      const mid = l.id ?? `m${step}`;
+      const msg = l.message;
+      const llmId = `llm:${mid}`;
+      const errored = !!msg.errorMessage;
+      spans.push(
+        span({
+          traceId,
+          spanId: llmId,
+          parentSpanId: rootId,
+          name: `message.${msg.role ?? "unknown"}`,
+          kind: "LLM",
+          startTime: ts,
+          status: errored ? "ERROR" : "OK",
+          statusMessage: errored ? msg.errorMessage.slice(0, 500) : void 0,
+          service: SERVICE8,
+          agent: SERVICE8,
+          model: msg.model ?? null,
+          inputTokens: msg.usage?.input ?? null,
+          outputTokens: msg.usage?.output ?? null,
+          step,
+          content: textOf(msg.content).slice(0, 8e3) || null
+        })
+      );
+      step += 1;
+      for (const b of msg.content ?? []) {
+        if (isToolBlock(b)) {
+          const name = b.toolName ?? b.name ?? "tool";
+          const callId = b.id ?? b.callId ?? b.toolCallId ?? `${mid}:${step}`;
+          const toolSpan = span({
+            traceId,
+            spanId: `tool:${callId}`,
+            parentSpanId: llmId,
+            name: `tool.${name}`,
+            kind: "TOOL",
+            startTime: ts,
+            service: SERVICE8,
+            agent: SERVICE8,
+            tool: name,
+            step,
+            content: (b.input ?? b.args) != null ? JSON.stringify(b.input ?? b.args) : null
+          });
+          spans.push(toolSpan);
+          toolByCallId.set(callId, toolSpan);
+          step += 1;
+        } else if (isToolResultBlock(b)) {
+          const callId = b.toolCallId ?? b.callId ?? b.id ?? "";
+          const t = toolByCallId.get(callId);
+          if (t) {
+            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" };
+          }
+        }
+      }
+    }
+    return spans;
+  }
+};
+
+// src/adapters/qwen.ts
+import { readdir as readdir10, readFile as readFile10, stat as stat10 } from "fs/promises";
+import { homedir as homedir10 } from "os";
+import { basename as basename7, join as join10 } 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 textOf2(parts) {
+  if (!parts) return "";
+  return parts.filter((p) => typeof p.text === "string").map((p) => p.text).join("");
+}
+var QwenAdapter = class {
+  harness = "qwen";
+  aliases = ["qwen-code"];
+  root() {
+    return join10(homedir10(), ".qwen", "projects");
+  }
+  async locate(opts = {}) {
+    const root = this.root();
+    let projectDirs;
+    try {
+      projectDirs = await readdir10(root);
+    } catch {
+      return [];
+    }
+    const refs = [];
+    for (const pd of projectDirs) {
+      const chatsDir = join10(root, pd, "chats");
+      let files;
+      try {
+        files = await readdir10(chatsDir);
+      } catch {
+        continue;
+      }
+      if (opts.cwd) continue;
+      for (const f of files) {
+        if (!f.endsWith(".jsonl")) continue;
+        const path = join10(chatsDir, f);
+        let st;
+        try {
+          st = await stat10(path);
+        } catch {
+          continue;
+        }
+        if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
+        refs.push({ harness: this.harness, sessionId: basename7(f, ".jsonl"), path, cwd: null, mtimeMs: st.mtimeMs });
+      }
+    }
+    return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }
+  async parse(ref) {
+    const records = parseLines6(await readFile10(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
+      })
+    ];
+    const openToolsByName = /* @__PURE__ */ new Map();
+    let step = 0;
+    let lastLlm = rootId;
+    for (const r of records) {
+      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,
+            spanId: llmId,
+            parentSpanId: rootId,
+            name: "llm.turn",
+            kind: "LLM",
+            startTime: ts,
+            service: SERVICE9,
+            agent: SERVICE9,
+            model: r.model ?? null,
+            inputTokens: r.usageMetadata?.promptTokenCount ?? null,
+            outputTokens: r.usageMetadata?.candidatesTokenCount ?? null,
+            step,
+            content: textOf2(r.message?.parts).slice(0, 8e3) || 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,
+            spanId: `tool:${name}:${step}`,
+            parentSpanId: llmId,
+            name: `tool.${name}`,
+            kind: "TOOL",
+            startTime: ts,
+            service: SERVICE9,
+            agent: SERVICE9,
+            tool: name,
+            step,
+            content: p.functionCall.args != null ? JSON.stringify(p.functionCall.args) : null
+          });
+          spans.push(t);
+          const q = openToolsByName.get(name) ?? [];
+          q.push(t);
+          openToolsByName.set(name, q);
+          step += 1;
+        }
+      } else if (r.type === "tool_result") {
+        const err = r.toolCallResult?.status === "error" || r.toolCallResult?.error != null;
+        for (const p of r.message?.parts ?? []) {
+          const name = p.functionResponse?.name;
+          if (!name) continue;
+          const t = openToolsByName.get(name)?.shift();
+          if (t) {
+            t.end_time = ts;
+            t.status = err ? { code: "ERROR", message: "tool result reported error" } : { code: "OK" };
+          }
+        }
+      }
+    }
+    return spans;
+  }
+};
+
+// src/registry.ts
+var ADAPTERS = [
+  new ClaudeAdapter(),
+  new CodexAdapter(),
+  new OpencodeAdapter(),
+  new GeminiAdapter(),
+  new QwenAdapter(),
+  new FactoryAdapter(),
+  new PiAdapter(),
+  new AmpAdapter(),
+  new CopilotAdapter(),
+  new ForgeAdapter()
+];
+var BY_NAME = /* @__PURE__ */ new Map();
+for (const a of ADAPTERS) {
+  BY_NAME.set(a.harness, a);
+  for (const alias of a.aliases ?? []) BY_NAME.set(alias, a);
+}
+function listAdapters() {
+  return ADAPTERS;
+}
+function resolveAdapter(harness) {
+  return BY_NAME.get(harness) ?? BY_NAME.get(harness.toLowerCase());
+}
+function knownHarnesses() {
+  return [...BY_NAME.keys()].sort();
+}
+
+// src/observer.ts
+var sleep = (ms2, signal) => new Promise((resolve) => {
+  const onAbort = () => {
+    clearTimeout(t);
+    resolve();
+  };
+  const t = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms2);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+function adaptersFor(opts) {
+  if (opts.adapters && opts.adapters.length > 0) return opts.adapters;
+  if (opts.all || !opts.harnesses || opts.harnesses.length === 0) return [...listAdapters()];
+  const out = [];
+  for (const h of opts.harnesses) {
+    const a = resolveAdapter(h);
+    if (a && !out.includes(a)) out.push(a);
+  }
+  return out;
+}
+function loopKey(sessionId, toolName, argHash) {
+  return `${sessionId}\0${toolName}\0${argHash}`;
+}
+async function watchSessions(opts) {
+  const windowMs = opts.windowMs ?? 30 * 6e4;
+  const intervalMs = Math.max(250, opts.intervalMs ?? 5e3);
+  const minLoop = opts.minLoopOccurrences ?? 3;
+  const adapters = adaptersFor(opts);
+  const seen = /* @__PURE__ */ new Map();
+  while (!opts.signal?.aborted) {
+    const sinceMs = Date.now() - windowMs;
+    let sessionCount = 0;
+    for (const adapter of adapters) {
+      if (opts.signal?.aborted) break;
+      let refs;
+      try {
+        refs = await adapter.locate({ cwd: opts.cwd, sinceMs });
+      } catch (err) {
+        opts.onError?.(err);
+        continue;
+      }
+      for (const ref of refs) {
+        if (opts.signal?.aborted) break;
+        let report;
+        try {
+          const spans = await adapter.parse(ref);
+          if (spans.length === 0) continue;
+          report = await runPipelines(spans, { minLoopOccurrences: minLoop });
+        } catch (err) {
+          opts.onError?.(err, ref);
+          continue;
+        }
+        sessionCount += 1;
+        if (opts.onReport) {
+          try {
+            await opts.onReport(ref, report);
+          } catch (err) {
+            opts.onError?.(err, ref);
+          }
+        }
+        for (const f of report.stuckLoops.findings) {
+          const key = loopKey(ref.sessionId, f.toolName, f.argHash);
+          if (f.occurrences > (seen.get(key) ?? 0)) {
+            seen.set(key, f.occurrences);
+            if (opts.onLoop) {
+              try {
+                await opts.onLoop({
+                  harness: adapter.harness,
+                  sessionId: ref.sessionId,
+                  cwd: ref.cwd,
+                  toolName: f.toolName,
+                  argHash: f.argHash,
+                  occurrences: f.occurrences,
+                  windowMs: f.windowMs
+                });
+              } catch (err) {
+                opts.onError?.(err, ref);
+              }
+            }
+          }
+        }
+      }
+    }
+    try {
+      opts.onTick?.({ sessions: sessionCount });
+    } catch (err) {
+      opts.onError?.(err);
+    }
+    if (opts.signal?.aborted) break;
+    await sleep(intervalMs, opts.signal);
+  }
+}
+
+// src/redact.ts
+import { DEFAULT_REDACTION_RULES, redactValue } from "@tangle-network/agent-eval/traces";
+var CODING_REDACTION_RULES = [
+  { id: "github-token", pattern: /\b(?:gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{22,})\b/g },
+  { id: "aws-akid", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
+  { id: "slack-token", pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g },
+  { id: "jwt", pattern: /\beyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g },
+  { id: "bearer", pattern: /\bBearer\s+[A-Za-z0-9._-]{16,}/gi },
+  {
+    id: "private-key",
+    pattern: /-----BEGIN(?:[A-Z ]+)?PRIVATE KEY-----[\s\S]*?-----END(?:[A-Z ]+)?PRIVATE KEY-----/g
+  },
+  {
+    id: "assigned-secret",
+    pattern: /\b(?:api[_-]?key|secret|token|password|passwd|access[_-]?token|client[_-]?secret)\b\s*[:=]\s*["']?[A-Za-z0-9._\-]{12,}["']?/gi
+  }
+];
+var TRACES_REDACTION_RULES = [...DEFAULT_REDACTION_RULES, ...CODING_REDACTION_RULES];
+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;
+    let status = s.status;
+    if (status.message) {
+      const m = redactValue(status.message, rules, report).value;
+      if (typeof m === "string" && m !== status.message) status = { ...status, message: m };
+    }
+    return { ...s, attributes, status };
+  });
+  return { spans: out, report };
+}
+
+// src/upload-state.ts
+import { createHash } from "crypto";
+import { mkdir, readFile as readFile11, writeFile } from "fs/promises";
+import { homedir as homedir11 } from "os";
+import { dirname, join as join11 } from "path";
+function stateFile() {
+  const base = process.env.XDG_STATE_HOME ?? join11(homedir11(), ".local", "state");
+  return join11(base, "tangle-traces", "uploaded.json");
+}
+function uploadKey(harness, sessionId) {
+  return `${harness}:${sessionId}`;
+}
+function sessionHash(spans) {
+  const h = createHash("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);
+}
+async function loadState() {
+  try {
+    return JSON.parse(await readFile11(stateFile(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function saveState(state) {
+  const f = stateFile();
+  await mkdir(dirname(f), { recursive: true });
+  await writeFile(f, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+function alreadyUploaded(state, harness, sessionId, hash) {
+  return state[uploadKey(harness, sessionId)]?.hash === hash;
+}
+
+// src/upload.ts
+import { readFile as readFile12 } from "fs/promises";
+import { createRequire } from "module";
+import { hostname } from "os";
+import { basename as basename8, join as join12 } from "path";
+import { hostedClientFromEnv } from "@tangle-network/agent-eval/hosted";
+import { REDACTION_VERSION } from "@tangle-network/agent-eval/traces";
+var require2 = createRequire(import.meta.url);
+var TRACES_VERSION = require2("../package.json").version;
+function adaptersFor2(opts) {
+  if (opts.all) return [...listAdapters()];
+  const a = resolveAdapter(opts.harness ?? "claude-code");
+  if (!a) throw new Error(`unknown harness "${opts.harness}"`);
+  return [a];
+}
+async function planUpload(opts) {
+  const state = await loadState();
+  const items = [];
+  for (const adapter of adaptersFor2(opts)) {
+    let refs;
+    try {
+      refs = await adapter.locate({ cwd: opts.cwd, sinceMs: opts.sinceMs });
+    } catch (err) {
+      opts.onError?.(err);
+      continue;
+    }
+    for (const ref of refs) {
+      let raw;
+      try {
+        raw = await adapter.parse(ref);
+      } catch (err) {
+        opts.onError?.(err, ref);
+        continue;
+      }
+      if (raw.length === 0) continue;
+      const { spans, report } = redactSpans(raw);
+      const hash = sessionHash(spans);
+      items.push({
+        ref,
+        spans,
+        redaction: report,
+        hash,
+        isNew: !alreadyUploaded(state, ref.harness, ref.sessionId, hash)
+      });
+    }
+  }
+  return { items, state, sinceMs: opts.sinceMs };
+}
+async function gitBranch(cwd) {
+  if (!cwd) return void 0;
+  try {
+    const head = await readFile12(join12(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) {
+  const meta = {
+    "tangle.harness": item.ref.harness,
+    "tangle.source": basename8(item.ref.path),
+    "tangle.host": hostname(),
+    "tangle.uploaded_at": uploadedAt,
+    "tangle.uploader": `tangle-traces@${TRACES_VERSION}`,
+    "redaction.version": REDACTION_VERSION,
+    "redaction.count": item.redaction.redactionCount
+  };
+  if (item.ref.cwd) meta["tangle.cwd"] = item.ref.cwd;
+  const branch = await gitBranch(item.ref.cwd);
+  if (branch) meta["tangle.git_branch"] = branch;
+  return meta;
+}
+function epochMs(ts) {
+  if (!ts) return 0;
+  if (/^\d+$/.test(ts)) return Number(ts);
+  const n = Date.parse(ts);
+  return Number.isNaN(n) ? 0 : n;
+}
+var msToNano = (iso2) => epochMs(iso2) * 1e6;
+function toTraceSpanEvents(spans, rootMeta) {
+  return spans.map((s) => {
+    const attributes = {};
+    for (const [k, v] of Object.entries(s.attributes)) {
+      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") attributes[k] = v;
+      else if (v != null) attributes[k] = JSON.stringify(v);
+    }
+    if (s.parent_span_id === null) Object.assign(attributes, rootMeta);
+    const startNano = msToNano(s.start_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)),
+      attributes,
+      ...s.status.code === "UNSET" ? {} : { status: { code: s.status.code, ...s.status.message ? { message: s.status.message } : {} } }
+    };
+  });
+}
+async function executeUpload(plan, opts = {}) {
+  const newItems = plan.items.filter((i) => i.isNew);
+  const skipped = plan.items.length - newItems.length;
+  const redactionCount = newItems.reduce((n, i) => n + i.redaction.redactionCount, 0);
+  const uploadedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (opts.dryRun) {
+    const allSpans = newItems.flatMap((i) => i.spans);
+    const path = await writeOtlpFile(allSpans, opts.otlpOut);
+    return {
+      uploadedSessions: 0,
+      skippedSessions: skipped,
+      acceptedSpans: 0,
+      redactionCount,
+      dryRun: true,
+      otlpPath: path
+    };
+  }
+  const client = opts.backend ?? hostedClientFromEnv();
+  if (!client) {
+    throw new Error(
+      "upload: no backend. Pass opts.backend, or configure the hosted Tangle Intelligence client via TANGLE_INGEST_URL (or TANGLE_ORCHESTRATOR_URL), TANGLE_INGEST_API_KEY (or TANGLE_API_KEY), and TANGLE_TENANT_ID. Use --dry-run to preview without uploading."
+    );
+  }
+  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 res = await client.ingestTraces(events, idempotencyKey);
+    acceptedSpans += res.accepted;
+    state[uploadKey(item.ref.harness, item.ref.sessionId)] = {
+      hash: item.hash,
+      uploadedAt,
+      harness: item.ref.harness,
+      spanCount: item.spans.length
+    };
+    opts.log?.(`uploaded ${item.ref.harness} ${item.ref.sessionId.slice(0, 8)} \u2014 ${res.accepted} spans`);
+  }
+  await saveState(state);
+  return {
+    uploadedSessions: newItems.length,
+    skippedSessions: skipped,
+    acceptedSpans,
+    redactionCount,
+    dryRun: false
+  };
+}
+
+export {
+  span,
+  serializeSpans,
+  writeOtlpFile,
+  analyzeSpans,
+  toRuntimeStore,
+  runPipelines,
+  AmpAdapter,
+  ClaudeAdapter,
+  CodexAdapter,
+  CopilotAdapter,
+  FactoryAdapter,
+  ForgeAdapter,
+  GeminiAdapter,
+  OpencodeAdapter,
+  PiAdapter,
+  QwenAdapter,
+  listAdapters,
+  resolveAdapter,
+  knownHarnesses,
+  watchSessions,
+  CODING_REDACTION_RULES,
+  TRACES_REDACTION_RULES,
+  redactSpans,
+  uploadKey,
+  sessionHash,
+  loadState,
+  saveState,
+  alreadyUploaded,
+  planUpload,
+  toTraceSpanEvents,
+  executeUpload
+};