@tangle-network/traces 0.1.0

package/dist/cli.js

@@ -0,0 +1,1920 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { stat as stat11, writeFile as writeFile2 } from "fs/promises";
+
+// src/analyze.ts
+import { mkdtemp, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { buildDefaultAnalystRegistry } from "@tangle-network/agent-eval/analyst";
+import { OtlpFileTraceStore } from "@tangle-network/agent-eval/traces";
+
+// 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")}
+`;
+}
+
+// src/analyze.ts
+async function writeOtlp(spans, outPath) {
+  const path = outPath ?? join(await mkdtemp(join(tmpdir(), "cli-bridge-traces-")), "spans.otlp.jsonl");
+  await writeFile(path, serializeSpans(spans), "utf8");
+  return path;
+}
+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 writeOtlp(spans, opts.otlpOutPath);
+  const runId = opts.runId ?? `cli-bridge-${Date.now()}`;
+  const detStore = new OtlpFileTraceStore({ path: otlpPath, perCallByteCeiling: DETERMINISTIC_VIEW_CEILING });
+  await detStore.ensureIndexed();
+  const detRegistry = 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/pipelines.ts
+import { computeToolUseMetrics } from "@tangle-network/agent-eval";
+import { stuckLoopView } from "@tangle-network/agent-eval/pipelines";
+
+// 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
+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 as join2 } from "path";
+var SERVICE = "amp";
+var AmpAdapter = class {
+  harness = "amp";
+  threadsRoot() {
+    const base = process.env.XDG_DATA_HOME ?? join2(homedir(), ".local", "share");
+    return join2(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 = join2(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 join3 } from "path";
+var SERVICE2 = "claude-code";
+function parseLines(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+function inputTokens(u) {
+  if (!u) return null;
+  const v = (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+  return v > 0 ? v : null;
+}
+function asBlocks(content) {
+  return Array.isArray(content) ? content : [];
+}
+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 join3(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 = join3(root, dir);
+      let files;
+      try {
+        files = await readdir2(dirPath);
+      } catch {
+        continue;
+      }
+      for (const f of files) {
+        if (!f.endsWith(".jsonl")) continue;
+        const path = join3(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 main2 = parseClaudeStream(events, {
+      traceId,
+      agent: SERVICE2,
+      startStep: 0,
+      idPrefix: "",
+      rootParent: rootId
+    });
+    spans.push(...main2.spans);
+    await this.foldSubagents(ref, traceId, main2, spans);
+    return spans;
+  }
+  /** Parse `<session>/subagents/agent-*.jsonl`, parenting each under its Agent call. */
+  async foldSubagents(ref, traceId, main2, out) {
+    const subDir = join3(ref.path.replace(/\.jsonl$/, ""), "subagents");
+    let files;
+    try {
+      files = await readdir2(subDir);
+    } catch {
+      return;
+    }
+    let step = main2.nextStep;
+    for (const f of files) {
+      if (!f.endsWith(".jsonl")) continue;
+      const hash = basename2(f, ".jsonl");
+      let meta = {};
+      try {
+        meta = JSON.parse(await readFile2(join3(subDir, `${hash}.meta.json`), "utf8"));
+      } catch {
+      }
+      const parent = meta.toolUseId && main2.toolSpanByUseId.get(meta.toolUseId)?.span_id || `root:${traceId}`;
+      let raw;
+      try {
+        raw = await readFile2(join3(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 join4 } from "path";
+var SERVICE3 = "codex";
+function parseLines2(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+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 = join4(root, y);
+    let months;
+    try {
+      months = await readdir3(yp);
+    } catch {
+      continue;
+    }
+    for (const m of months) {
+      const mp = join4(yp, m);
+      let days;
+      try {
+        days = await readdir3(mp);
+      } catch {
+        continue;
+      }
+      for (const d of days) {
+        const dp = join4(mp, d);
+        let files;
+        try {
+          files = await readdir3(dp);
+        } catch {
+          continue;
+        }
+        for (const f of files) {
+          if (f.startsWith("rollout-") && f.endsWith(".jsonl")) yield join4(dp, f);
+        }
+      }
+    }
+  }
+}
+var CodexAdapter = class {
+  harness = "codex";
+  aliases = ["codex-acp"];
+  root() {
+    return process.env.CODEX_HOME ? join4(process.env.CODEX_HOME, "sessions") : join4(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 join5 } from "path";
+var SERVICE4 = "github-copilot";
+function parseLines3(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+var CopilotAdapter = class {
+  harness = "github-copilot";
+  aliases = ["copilot"];
+  root() {
+    return join5(process.env.COPILOT_HOME ?? join5(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 = join5(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 join6 } 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 join6(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 = join6(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 = join6(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 join7 } 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(), join7(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 = join7(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 join8 } 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 join8(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 = join8(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 = join8(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 join9 } 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 ?? join9(homedir8(), ".local", "share");
+    return join9(base, "opencode", "storage");
+  }
+  async locate(opts = {}) {
+    const msgRoot = join9(this.storage(), "message");
+    let sessionDirs;
+    try {
+      sessionDirs = await readdir8(msgRoot);
+    } catch {
+      return [];
+    }
+    const refs = [];
+    for (const sid of sessionDirs) {
+      const dir = join9(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 = join9(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(join9(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 = join9(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(join9(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 join10 } from "path";
+var SERVICE8 = "pi";
+function parseLines5(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+function isToolBlock(b) {
+  return typeof b.type === "string" && /tool[_-]?call|tool[_-]?use|^tool$/i.test(b.type);
+}
+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 join10(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 = join10(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 = join10(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 join11 } from "path";
+var SERVICE9 = "qwen";
+function parseLines6(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+function 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 join11(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 = join11(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 = join11(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/report.ts
+var SEVERITY_RANK = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+var SEVERITY_BADGE = {
+  critical: "\u{1F534} CRITICAL",
+  high: "\u{1F7E0} HIGH",
+  medium: "\u{1F7E1} MEDIUM",
+  low: "\u{1F535} LOW",
+  info: "\u2139\uFE0F  INFO"
+};
+function renderReport(result, meta) {
+  const lines = [];
+  const findings = [...result.findings].sort(
+    (a, b) => (SEVERITY_RANK[a.severity] ?? 9) - (SEVERITY_RANK[b.severity] ?? 9)
+  );
+  lines.push(`# Trace analysis \u2014 ${meta.harness}`);
+  lines.push("");
+  lines.push(
+    `${meta.sessionCount} session(s), ${meta.spanCount} spans \u2192 **${findings.length} findings** across ${result.per_analyst.length} analyst(s). Cost: $${result.total_cost_usd.toFixed(4)}.`
+  );
+  lines.push("");
+  lines.push("| Analyst | Status | Findings | Latency |");
+  lines.push("|---|---|---|---|");
+  for (const s of result.per_analyst) {
+    lines.push(`| \`${s.analyst_id}\` | ${s.status} | ${s.findings_count} | ${s.latency_ms}ms |`);
+  }
+  lines.push("");
+  if (findings.length === 0) {
+    lines.push("_No findings \u2014 no behavioral inefficiencies or failure modes detected._");
+  } else {
+    const byArea = /* @__PURE__ */ new Map();
+    for (const f of findings) {
+      const arr = byArea.get(f.area) ?? [];
+      arr.push(f);
+      byArea.set(f.area, arr);
+    }
+    for (const [area, arr] of byArea) {
+      lines.push(`## ${area} (${arr.length})`);
+      lines.push("");
+      for (const f of arr) {
+        lines.push(`### ${SEVERITY_BADGE[f.severity] ?? f.severity} \u2014 ${f.claim}`);
+        lines.push("");
+        if (f.subject) lines.push(`- **Subject:** \`${f.subject}\``);
+        lines.push(`- **Confidence:** ${f.confidence}`);
+        if (f.recommended_action) lines.push(`- **Fix:** ${f.recommended_action}`);
+        for (const ev of f.evidence_refs.slice(0, 3)) {
+          const excerpt = ev.excerpt ? ` \u2014 \`${ev.excerpt.slice(0, 200)}\`` : "";
+          lines.push(`- **Evidence:** ${ev.kind} ${ev.uri}${excerpt}`);
+        }
+        lines.push("");
+      }
+    }
+  }
+  lines.push("---");
+  lines.push(`OTLP artifact: \`${meta.otlpPath}\` \u2014 also runnable with \`halo ${meta.otlpPath} -p "diagnose"\`.`);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderPipelines(pr) {
+  const lines = ["## loops & waste (deterministic)", ""];
+  if (pr.stuckLoops.findings.length === 0) {
+    lines.push("- **Stuck loops:** none (no tool called \u22653\xD7 with identical args).");
+  } else {
+    lines.push(`- **Stuck loops:** ${pr.stuckLoops.findings.length} (${(pr.stuckLoops.affectedRunRatio * 100).toFixed(0)}% of runs affected)`);
+    for (const f of pr.stuckLoops.findings.sort((a, b) => b.occurrences - a.occurrences).slice(0, 10)) {
+      lines.push(`  - \u{1F501} \`${f.toolName}\` \xD7${f.occurrences} with identical args over ${(f.windowMs / 1e3).toFixed(1)}s`);
+    }
+  }
+  for (const m of pr.toolUse) {
+    if (m.totalCalls === 0) continue;
+    lines.push(
+      `- **Tool use** (${m.totalCalls} calls): ${(m.duplicateRate * 100).toFixed(0)}% duplicate, ${(m.retryRate * 100).toFixed(0)}% retry, ${(m.errorRate * 100).toFixed(0)}% error`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const a = {
+    command: argv[0] ?? "help",
+    harness: "claude-code",
+    all: false,
+    last: 0,
+    llm: false,
+    interval: 5,
+    window: 30,
+    minLoop: 3
+  };
+  for (let i = 1; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => argv[++i];
+    switch (arg) {
+      case "--harness":
+        a.harness = next() ?? a.harness;
+        break;
+      case "--all":
+        a.all = true;
+        break;
+      case "--last":
+        a.last = Number(next());
+        break;
+      case "--session":
+        a.session = next();
+        break;
+      case "--cwd":
+        a.cwd = next();
+        break;
+      case "--since":
+        a.since = next();
+        break;
+      case "--out":
+        a.out = next();
+        break;
+      case "--otlp":
+        a.otlp = next();
+        break;
+      case "--llm":
+        a.llm = true;
+        break;
+      case "--budget":
+        a.budget = Number(next());
+        break;
+      case "--interval":
+        a.interval = Number(next());
+        break;
+      case "--window":
+        a.window = Number(next());
+        break;
+      case "--min-loop":
+        a.minLoop = Number(next());
+        break;
+      default:
+        if (arg?.startsWith("--")) throw new Error(`unknown flag: ${arg}`);
+    }
+  }
+  return a;
+}
+function adaptersFor(args) {
+  if (args.all) return [...listAdapters()];
+  const adapter = resolveAdapter(args.harness);
+  if (!adapter) {
+    throw new Error(`unknown harness "${args.harness}". Known: ${knownHarnesses().join(", ")}`);
+  }
+  return [adapter];
+}
+async function discover(args) {
+  const sinceMs = args.since ? Date.parse(args.since) : void 0;
+  const out = [];
+  for (const adapter of adaptersFor(args)) {
+    let refs = await adapter.locate({ cwd: args.cwd, sinceMs });
+    if (args.last > 0) refs = refs.slice(0, args.last);
+    out.push({ adapter, refs });
+  }
+  return out;
+}
+async function buildAxService() {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("--llm needs OPENAI_API_KEY for the agentic analyst kinds (deterministic analysis needs no key)");
+  }
+  const { AxAI } = await import("@ax-llm/ax");
+  return new AxAI({ name: "openai", apiKey });
+}
+async function cmdList(args) {
+  const groups = await discover({ ...args, last: args.last || 20 });
+  for (const { adapter, refs } of groups) {
+    console.log(`
+${adapter.harness} \u2014 ${refs.length} session(s)`);
+    for (const r of refs) {
+      console.log(`  ${new Date(r.mtimeMs).toISOString()}  ${r.sessionId}  ${r.cwd ?? ""}`);
+    }
+  }
+}
+async function collectSpans(args) {
+  if (args.session) {
+    const adapter = resolveAdapter(args.harness);
+    if (!adapter) throw new Error(`unknown harness "${args.harness}"`);
+    const st = await stat11(args.session);
+    const ref = {
+      harness: adapter.harness,
+      sessionId: args.session,
+      path: args.session,
+      cwd: null,
+      mtimeMs: st.mtimeMs
+    };
+    return { spans: await adapter.parse(ref), harness: adapter.harness, sessionCount: 1 };
+  }
+  const groups = await discover({ ...args, last: args.last || 1 });
+  const spans = [];
+  let sessionCount = 0;
+  const harnesses = [];
+  for (const { adapter, refs } of groups) {
+    if (refs.length > 0) harnesses.push(adapter.harness);
+    for (const ref of refs) {
+      spans.push(...await adapter.parse(ref));
+      sessionCount += 1;
+    }
+  }
+  return { spans, harness: harnesses.join("+") || args.harness, sessionCount };
+}
+async function cmdConvert(args) {
+  const { spans } = await collectSpans(args);
+  if (spans.length === 0) throw new Error("no spans found for the given selection");
+  const path = await writeOtlp(spans, args.otlp);
+  console.log(`wrote ${spans.length} spans \u2192 ${path}`);
+}
+async function cmdAnalyze(args) {
+  const { spans, harness, sessionCount } = await collectSpans(args);
+  if (spans.length === 0) throw new Error("no spans found for the given selection");
+  const ai = args.llm ? await buildAxService() : void 0;
+  const { otlpPath, result } = await analyzeSpans(spans, {
+    ai,
+    budgetUsd: args.budget,
+    otlpOutPath: args.otlp,
+    log: (msg) => process.stderr.write(`${msg}
+`)
+  });
+  const pipelines = await runPipelines(spans, { minLoopOccurrences: args.minLoop });
+  const report = `${renderReport(result, { harness, sessionCount, spanCount: spans.length, otlpPath })}
+${renderPipelines(pipelines)}`;
+  if (args.out) {
+    await writeFile2(args.out, report, "utf8");
+    console.log(`report \u2192 ${args.out}  (${result.findings.length} findings, ${pipelines.stuckLoops.findings.length} loops, OTLP: ${otlpPath})`);
+  } else {
+    console.log(report);
+  }
+}
+function loopKey(sessionId, toolName, argHash) {
+  return `${sessionId}|${toolName}|${argHash}`;
+}
+var sleep = (ms2) => new Promise((r) => setTimeout(r, ms2));
+async function cmdWatch(args) {
+  if (!args.all && !args.cwd) args.all = true;
+  const seen = /* @__PURE__ */ new Map();
+  const intervalMs = Math.max(1, args.interval) * 1e3;
+  process.stderr.write(
+    `traces watch \u2014 observing ${args.all ? "all harnesses" : args.harness}, sessions active in the last ${args.window}m, every ${args.interval}s. Read-only; Ctrl-C to stop.
+`
+  );
+  for (; ; ) {
+    const sinceMs = Date.now() - args.window * 6e4;
+    for (const adapter of adaptersFor(args)) {
+      let refs;
+      try {
+        refs = await adapter.locate({ cwd: args.cwd, sinceMs });
+      } catch {
+        continue;
+      }
+      for (const ref of refs) {
+        let report;
+        try {
+          const spans = await adapter.parse(ref);
+          if (spans.length === 0) continue;
+          report = await runPipelines(spans, { minLoopOccurrences: args.minLoop });
+        } catch {
+          continue;
+        }
+        for (const f of report.stuckLoops.findings) {
+          const key = loopKey(ref.sessionId, f.toolName, f.argHash);
+          const prior = seen.get(key) ?? 0;
+          if (f.occurrences > prior) {
+            seen.set(key, f.occurrences);
+            const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+            process.stdout.write(
+              `\u26A0\uFE0F  ${ts} [${adapter.harness}] ${ref.sessionId.slice(0, 8)} \u2014 \`${f.toolName}\` repeated \xD7${f.occurrences} with identical args (${(f.windowMs / 1e3).toFixed(0)}s)${ref.cwd ? ` \xB7 ${ref.cwd}` : ""}
+`
+            );
+          }
+        }
+      }
+    }
+    await sleep(intervalMs);
+  }
+}
+function usage() {
+  console.log(`traces \u2014 analyze & observe coding-agent sessions
+
+Commands:
+  list      List discovered sessions
+  analyze   Run analyst suite + loop/waste pipelines, write a markdown report
+  convert   Emit OTLP-JSONL only (also feeds HALO)
+  watch     Online observer: tail active sessions, notify on stuck loops (read-only)
+
+Options:
+  --harness <id>   Harness or alias (default: claude-code). Known: ${knownHarnesses().join(", ")}
+  --all            Sweep every known harness
+  --last <n>       Most-recent N sessions
+  --session <path> Analyze one explicit session file
+  --cwd <dir>      Filter sessions by working directory
+  --since <iso>    Only sessions modified since this time
+  --out <path>     Write report to a file
+  --otlp <path>    OTLP artifact path
+  --llm            Enable agentic RLM analysts (needs OPENAI_API_KEY)
+  --budget <usd>   USD cap for agentic analysts
+  --interval <s>   watch: poll interval seconds (default 5)
+  --window <m>     watch: only sessions active in the last N minutes (default 30)
+  --min-loop <n>   Min identical repeated calls to flag a loop (default 3)`);
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  switch (args.command) {
+    case "list":
+      await cmdList(args);
+      break;
+    case "analyze":
+      await cmdAnalyze(args);
+      break;
+    case "convert":
+      await cmdConvert(args);
+      break;
+    case "watch":
+      await cmdWatch(args);
+      break;
+    default:
+      usage();
+  }
+}
+main().catch((err) => {
+  process.stderr.write(`error: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exitCode = 1;
+});