@tangle-network/traces 0.8.0 → 0.8.11

package/dist/{chunk-BUD6I3ZJ.js → chunk-PRRWLKSI.js}

@@ -1,3 +1,110 @@
+// src/adoption.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+function toolName(s) {
+  const n = s.attributes["tool.name"];
+  if (typeof n === "string") return n;
+  if (s.name.startsWith("tool.")) return s.name.slice("tool.".length);
+  return null;
+}
+function parseInput(s) {
+  const c = s.attributes.content;
+  if (typeof c !== "string") return {};
+  try {
+    const v = JSON.parse(c);
+    return v && typeof v === "object" ? v : {};
+  } catch {
+    return {};
+  }
+}
+function skillNameOf(input) {
+  const v = input.skill ?? input.command;
+  return typeof v === "string" && v.length > 0 ? v : "?";
+}
+function subagentTypeOf(input) {
+  const v = input.subagent_type;
+  return typeof v === "string" && v.length > 0 ? v : "?";
+}
+function countSkillRunsJsonl(raw) {
+  const out = {};
+  for (const line of raw.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    let o;
+    try {
+      o = JSON.parse(t);
+    } catch {
+      continue;
+    }
+    if (!o || typeof o !== "object") continue;
+    const rec = o;
+    const names = [];
+    if (Array.isArray(rec.skills)) {
+      for (const s of rec.skills) if (typeof s === "string" && s) names.push(s);
+    }
+    if (typeof rec.skill === "string" && rec.skill) names.push(rec.skill);
+    if (names.length === 0) names.push("?");
+    for (const n of names) out[n] = (out[n] ?? 0) + 1;
+  }
+  return out;
+}
+async function readLoopRuns(cwds) {
+  const counts = {};
+  let filesRead = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const cwd of cwds) {
+    if (!cwd || seen.has(cwd)) continue;
+    seen.add(cwd);
+    const path = join(cwd, ".evolve", "skill-runs.jsonl");
+    let raw;
+    try {
+      raw = await readFile(path, "utf8");
+    } catch {
+      continue;
+    }
+    filesRead += 1;
+    for (const [k, v] of Object.entries(countSkillRunsJsonl(raw))) counts[k] = (counts[k] ?? 0) + v;
+  }
+  return { counts, filesRead };
+}
+async function analyzeAdoption(spans, opts = {}) {
+  const sessions = /* @__PURE__ */ new Set();
+  const sessionsWithSkill = /* @__PURE__ */ new Set();
+  const sessionsWithSubagent = /* @__PURE__ */ new Set();
+  const skillInvocations = {};
+  const subagentSpawns = {};
+  for (const s of spans) {
+    sessions.add(s.trace_id);
+    const tn = toolName(s);
+    if (tn === "Skill") {
+      const name = skillNameOf(parseInput(s));
+      skillInvocations[name] = (skillInvocations[name] ?? 0) + 1;
+      sessionsWithSkill.add(s.trace_id);
+    } else if (tn === "Task" || tn === "Agent") {
+      const type = subagentTypeOf(parseInput(s));
+      subagentSpawns[type] = (subagentSpawns[type] ?? 0) + 1;
+      sessionsWithSubagent.add(s.trace_id);
+    }
+  }
+  const { counts: loopDispatchedRuns, filesRead } = await readLoopRuns(opts.cwds ?? []);
+  const totalSkillInvocations = Object.values(skillInvocations).reduce((a, b) => a + b, 0);
+  const totalSubagentSpawns = Object.values(subagentSpawns).reduce((a, b) => a + b, 0);
+  const totalLoopDispatchedRuns = Object.values(loopDispatchedRuns).reduce((a, b) => a + b, 0);
+  return {
+    sessionCount: sessions.size,
+    sessionsWithSkill: sessionsWithSkill.size,
+    skillPenetration: sessions.size === 0 ? 0 : sessionsWithSkill.size / sessions.size,
+    skillInvocations,
+    totalSkillInvocations,
+    subagentSpawns,
+    totalSubagentSpawns,
+    sessionsWithSubagent: sessionsWithSubagent.size,
+    loopDispatchedRuns,
+    totalLoopDispatchedRuns,
+    skillRunFilesRead: filesRead
+  };
+}
+
 // src/otlp.ts
 function span(input) {
   const attributes = {
@@ -30,6 +137,9 @@ function toOpenInferenceSpan(s) {
   const resourceAttrs = {};
   if (a["service.name"] != null) resourceAttrs["service.name"] = a["service.name"];
   if (a["agent.name"] != null) resourceAttrs["agent.name"] = a["agent.name"];
+  for (const k of ["tangle.subject.key", "git.repository", "git.branch", "git.commit", "tangle.cwd", "traces.repo_resolution_source"]) {
+    if (a[k] != null) resourceAttrs[k] = a[k];
+  }
   return {
     trace_id: s.trace_id,
     span_id: s.span_id,
@@ -50,11 +160,11 @@ function serializeSpans(spans) {
 `;
 }
 async function writeOtlpFile(spans, outPath) {
-  const { mkdtemp, writeFile: writeFile3 } = 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 writeFile3(path, serializeSpans(spans), "utf8");
+  const { mkdtemp: mkdtemp5, writeFile: writeFile6 } = await import("fs/promises");
+  const { tmpdir: tmpdir5 } = await import("os");
+  const { join: join19 } = await import("path");
+  const path = outPath ?? join19(await mkdtemp5(join19(tmpdir5(), "traces-")), "spans.otlp.jsonl");
+  await writeFile6(path, serializeSpans(spans), "utf8");
   return path;
 }
 
@@ -89,150 +199,39 @@ async function analyzeSpans(spans, opts = {}) {
   return { otlpPath, result };
 }
 
-// src/external.ts
-import { spawn } from "child_process";
-import { readFile, writeFile } from "fs/promises";
-function runCommand(command, args = [], opts = {}) {
-  const timeoutMs = opts.timeoutMs ?? 12e4;
-  const maxBuffer = opts.maxBuffer ?? 32 * 1024 * 1024;
-  return new Promise((resolve, reject) => {
-    let child;
-    try {
-      child = spawn(command, [...args], { signal: opts.signal });
-    } catch (err2) {
-      reject(err2 instanceof Error ? err2 : new Error(String(err2)));
-      return;
-    }
-    let out = "";
-    let err = "";
-    let killed = false;
-    const timer = setTimeout(() => {
-      killed = true;
-      child.kill("SIGKILL");
-      reject(new Error(`${command}: timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-    const cap = (add, buf) => {
-      const next = buf + add;
-      if (next.length > maxBuffer) {
-        killed = true;
-        child.kill("SIGKILL");
-        clearTimeout(timer);
-        reject(new Error(`${command}: output exceeded ${maxBuffer} bytes`));
-      }
-      return next;
-    };
-    child.stdout?.on("data", (d) => {
-      out = cap(String(d), out);
-    });
-    child.stderr?.on("data", (d) => {
-      err = cap(String(d), err);
-    });
-    child.on("error", (e) => {
-      clearTimeout(timer);
-      if (!killed) reject(e);
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      if (!killed) resolve({ stdout: out, stderr: err, code });
-    });
-    if (opts.input !== void 0) {
-      child.stdin?.on("error", () => {
-      });
-      child.stdin?.end(opts.input);
-    }
-  });
-}
-function commandAnalyzer(spec) {
-  return {
-    name: spec.name,
-    async analyze(otlpPath, opts = {}) {
-      try {
-        const res = await runCommand(spec.command, spec.args(otlpPath, opts.prompt), {
-          signal: opts.signal,
-          timeoutMs: spec.timeoutMs
-        });
-        if (res.code !== 0) {
-          return { analyzer: spec.name, ok: false, output: res.stdout, error: res.stderr.trim() || `exit ${res.code}` };
-        }
-        return { analyzer: spec.name, ok: true, output: res.stdout.trim(), findings: spec.parse?.(res.stdout) };
-      } catch (e) {
-        return { analyzer: spec.name, ok: false, output: "", error: e instanceof Error ? e.message : String(e) };
-      }
-    }
-  };
-}
-function toCanonicalOpenInference(otlpJsonl, opts = {}) {
-  return otlpJsonl.split("\n").filter((l) => l.trim()).map((line) => {
-    const s = JSON.parse(line);
-    const a = s.attributes ?? {};
-    const resourceAttrs = { "service.name": a["service.name"] ?? opts.service ?? "traces" };
-    if (a["agent.name"]) resourceAttrs["agent.name"] = a["agent.name"];
-    return JSON.stringify({
-      trace_id: s.trace_id,
-      span_id: s.span_id,
-      parent_span_id: s.parent_span_id ?? "",
-      trace_state: "",
-      name: s.name,
-      kind: a["openinference.span.kind"] ?? "CHAIN",
-      start_time: s.start_time,
-      end_time: s.end_time,
-      status: { code: s.status?.code ?? "OK", message: s.status?.message ?? "" },
-      resource: { attributes: resourceAttrs },
-      scope: { name: opts.scopeName ?? "tangle-traces", version: "" },
-      attributes: a
-    });
-  }).join("\n");
-}
-function haloAnalyzer(opts = {}) {
-  const command = opts.command ?? "halo";
-  const defaultPrompt = opts.defaultPrompt ?? "diagnose";
-  return {
-    name: "halo",
-    async analyze(otlpPath, o = {}) {
-      try {
-        const canonical = toCanonicalOpenInference(await readFile(otlpPath, "utf8"));
-        const canonPath = `${otlpPath}.halo.jsonl`;
-        await writeFile(canonPath, canonical);
-        const args = [canonPath, "-p", o.prompt ?? defaultPrompt];
-        if (opts.model) args.push("-m", opts.model);
-        const res = await runCommand(command, args, { signal: o.signal, timeoutMs: opts.timeoutMs });
-        if (res.code !== 0) {
-          return { analyzer: "halo", ok: false, output: res.stdout, error: res.stderr.trim() || `exit ${res.code}` };
-        }
-        return { analyzer: "halo", ok: true, output: res.stdout.trim() };
-      } catch (e) {
-        return { analyzer: "halo", ok: false, output: "", error: e instanceof Error ? e.message : String(e) };
-      }
-    }
-  };
-}
-function runExternalAnalyzers(otlpPath, analyzers, opts = {}) {
-  return Promise.all(analyzers.map((a) => a.analyze(otlpPath, opts)));
-}
-function commandRedactor(spec) {
-  const name = spec.name ?? spec.command;
-  return {
-    name,
-    async redactText(texts) {
-      if (texts.length === 0) return [];
-      const res = await runCommand(spec.command, spec.args ?? [], {
-        input: JSON.stringify(texts),
-        timeoutMs: spec.timeoutMs
-      });
-      if (res.code !== 0) throw new Error(`redactor ${name}: exit ${res.code}: ${res.stderr.trim()}`);
-      let parsed;
-      try {
-        parsed = JSON.parse(res.stdout);
-      } catch {
-        throw new Error(`redactor ${name}: stdout was not JSON`);
-      }
-      if (!Array.isArray(parsed) || parsed.length !== texts.length) {
-        throw new Error(`redactor ${name}: expected a JSON array of ${texts.length} strings`);
-      }
-      return parsed.map(String);
-    }
-  };
-}
+// src/attributes.ts
+var ATTR = {
+  /** = the trace/session id. Wire contract (dedup linkage). */
+  SESSION_ID: "tangle.sessionId",
+  /** "cli" marks a CLI upload so the platform can drop a re-upload of a session
+   *  that also streamed live. Wire contract. */
+  INGEST_SOURCE: "tangle.ingest_source",
+  HARNESS: "tangle.harness",
+  CWD: "tangle.cwd",
+  /** THE per-session grouping key the spine derives subjects from
+   *  (`deriveSubjectKey` reads `tangle.subject.key` first). Resolves to the git
+   *  remote (host/owner/repo) when readable, else the cwd path basename. */
+  SUBJECT_KEY: "tangle.subject.key",
+  /** Normalized git remote (e.g. `github.com/tangle-network/agent-dev-container`). */
+  GIT_REPOSITORY: "git.repository",
+  /** Current branch at conversion time. */
+  GIT_BRANCH_NAME: "git.branch",
+  /** HEAD short sha at conversion time. */
+  GIT_COMMIT: "git.commit",
+  /** How traces resolved the session cwd: recorded cwd, repaired cwd, or span path. */
+  REPO_RESOLUTION_SOURCE: "traces.repo_resolution_source",
+  GIT_BRANCH: "tangle.git_branch",
+  HOST: "tangle.host",
+  /** Basename of the session file. (Renamed from the ambiguous `tangle.source`,
+   *  which collided with `tangle.ingest_source`.) */
+  SESSION_FILE: "tangle.session_file",
+  UPLOADED_AT: "tangle.uploaded_at",
+  UPLOADER: "tangle.uploader",
+  REDACTION_VERSION: "redaction.version",
+  REDACTION_COUNT: "redaction.count"
+};
+var INGEST_SOURCE_CLI = "cli";
+var DEFAULT_HARNESS = "claude-code";
 
 // src/time.ts
 function parseIsoToEpochMs(ts) {
@@ -310,6 +309,7 @@ function capText(raw) {
   if (t.length <= CONTENT_CAP) return t;
   return `${t.slice(0, CONTENT_CAP)}\u2026 [+${t.length - CONTENT_CAP} chars]`;
 }
+var ACTOR_ATTR = "tangle.actor";
 function userPromptSpan(o) {
   return span({
     traceId: o.traceId,
@@ -321,14 +321,15 @@ function userPromptSpan(o) {
     service: o.service ?? null,
     agent: o.agent ?? null,
     step: o.step,
-    content: o.content
+    content: o.content,
+    extra: { [ACTOR_ATTR]: o.actor ?? "human" }
   });
 }
 
 // src/adapters/amp.ts
 import { readdir, readFile as readFile2, stat } from "fs/promises";
 import { homedir } from "os";
-import { basename, join } from "path";
+import { basename, join as join2 } from "path";
 var SERVICE = "amp";
 function textOf(content) {
   if (typeof content === "string") return content.slice(0, CONTENT_CAP);
@@ -339,8 +340,8 @@ function textOf(content) {
 var AmpAdapter = class {
   harness = "amp";
   threadsRoot() {
-    const base = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
-    return join(base, "amp", "threads");
+    const base = process.env.XDG_DATA_HOME ?? join2(homedir(), ".local", "share");
+    return join2(base, "amp", "threads");
   }
   async locate(opts = {}) {
     let files;
@@ -352,7 +353,7 @@ var AmpAdapter = class {
     const refs = [];
     for (const f of files) {
       if (!f.startsWith("T-") || !f.endsWith(".json")) continue;
-      const path = join(this.threadsRoot(), f);
+      const path = join2(this.threadsRoot(), f);
       let st;
       try {
         st = await stat(path);
@@ -451,10 +452,98 @@ var AmpAdapter = class {
   }
 };
 
+// src/adapters/actor.ts
+var CMD_MARKERS = [
+  "<command-name>",
+  "<local-command-caveat>",
+  "<command-message>",
+  "<command-args>",
+  "<command-stdout>"
+];
+var INJECT_MARKERS = [
+  "<system-reminder>",
+  "Caveat: The messages below",
+  "<user-memory-input>",
+  // Harness-injected wrappers that arrive as `userType: external` user turns —
+  // they pass the structural human test but are the harness feeding the model,
+  // not a person. (Observed in Claude Code task/loop sessions.)
+  "<task-notification>",
+  "<task-prompt>",
+  "<local-command-stdout>",
+  "This session is being continued from a previous conversation",
+  // Slash-command skill bodies are expanded into a user turn (no <command-name>
+  // wrapper) — the skill prompt, not the human.
+  "Base directory for this skill:"
+];
+var SYNTHETIC_MARKERS = [
+  "You are in a development environment with full file system access",
+  "## What the user asked for",
+  "Build the project described below",
+  "Filesystem sandboxing defines",
+  "<permissions instructions>",
+  "You are an autonomous",
+  "You are a coding agent",
+  "Your task is to build",
+  "## Deliverable",
+  "## Acceptance criteria",
+  "Return ONLY",
+  "respond with JSON",
+  "<environment_details>",
+  "<task>",
+  "Review this change before it is pushed",
+  "Complete a security review",
+  "Focus on correctness, regressions, security issues",
+  "Read-only critical audit",
+  "Staff-engineer code review"
+];
+var AGENT_PROMPT = /^(you are\b|you're\b|read[- ]only\b|stop now\b|your task\b|your job\b|review the\b|audit\b|analyze the\b|return (only|a |the )|here is the\b|context:|task:|do not (revert|edit|touch)|work only in\b|you have been\b|act as\b|operate the\b|goal:|objective:)/i;
+function textIsCmdOrInject(s) {
+  return CMD_MARKERS.some((m) => s.includes(m)) || INJECT_MARKERS.some((m) => s.includes(m));
+}
+function textIsSynthetic(s) {
+  const head = s.slice(0, 600);
+  return SYNTHETIC_MARKERS.some((m) => head.includes(m));
+}
+function looksLikeAgentPrompt(s) {
+  const t = s.trim();
+  if (t.length > 1500) return true;
+  return AGENT_PROMPT.test(t);
+}
+function claudeActor(args) {
+  if (args.isSidechain === true) return "subagent-spawn";
+  if (args.userType != null && args.userType !== "external") return "injected";
+  if (textIsCmdOrInject(args.text)) return "injected";
+  if (textIsSynthetic(args.text)) return "injected";
+  if (args.isFirstUserTurn && looksLikeAgentPrompt(args.text)) return "subagent-spawn";
+  return "human";
+}
+function codexActor(args) {
+  if (textIsCmdOrInject(args.text)) return "injected";
+  if (textIsSynthetic(args.text)) return "injected";
+  if (args.isFirstUserTurn && looksLikeAgentPrompt(args.text)) return "injected";
+  return "human";
+}
+var JARGON_COMPLAINT = /\b(jargon|plain english|plain language|eli5|explain like|in plain|what does that mean|what does .* mean|i don'?t (understand|get)|gibberish|english please|too technical|speak (plainly|english)|dumb(ed)? it down|simpler|simplify your|no buzzwords?)\b/;
+var STRUCTURE_COMPLAINT = /\b(too long|tl;?dr|get to the point|bluf|lead with|bullet|bulletpoint|wall of text|too verbose|shorter|be concise|stop (yapping|rambling)|less words?|fewer words?|just (the|tell me)|cut the)\b/;
+var CORRECTION = /(\bno[,. ]|^no\b|\bstop\b|\bdon'?t\b|you keep|i (said|told you|asked)|that'?s not (what|right|it)|not what i|didn'?t ask|incorrect|that'?s wrong|you'?re wrong|why are you|why did you|that'?s not the|missed the|not the point|ur wrong|thats not)/;
+var FRUSTRATION = /(ugh|wtf|wth|come on|seriously|again\?|for the (last|nth) time|are you kidding|jesus|christ|frustrat|annoying|wasting|waste of)/;
+var PRAISE = /\b(perfect|exactly|nailed it|love (it|this)|beautiful|great work|ship it|clean|nice work|excellent|that'?s it|yes!+|amazing|chef'?s kiss|brilliant)\b/;
+function classifyReaction(text) {
+  const t = text.toLowerCase();
+  const hits = [];
+  if (JARGON_COMPLAINT.test(t)) hits.push("jargon");
+  if (STRUCTURE_COMPLAINT.test(t)) hits.push("structure");
+  if (CORRECTION.test(t)) hits.push("correction");
+  if (FRUSTRATION.test(t)) hits.push("frustration");
+  if (PRAISE.test(t)) hits.push("praise");
+  return hits;
+}
+var CORRECTIVE_REACTIONS = ["correction", "frustration", "jargon", "structure"];
+
 // src/adapters/claude.ts
 import { readdir as readdir2, readFile as readFile3, stat as stat2 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { basename as basename2, join as join2 } from "path";
+import { basename as basename2, join as join3 } from "path";
 var SERVICE2 = "claude-code";
 function parseLines(raw) {
   const out = [];
@@ -492,6 +581,7 @@ function parseClaudeStream(events, ctx) {
   const spans = [];
   const toolSpanByUseId = /* @__PURE__ */ new Map();
   let step = ctx.startStep;
+  let sawUserTurn = false;
   for (const ev of events) {
     const ts = ev.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
     const uid = ev.uuid ?? `${ctx.idPrefix}step${step}`;
@@ -539,6 +629,13 @@ function parseClaudeStream(events, ctx) {
     } else if (ev.type === "user" && ev.message) {
       const prompt = textOf2(ev.message.content);
       if (prompt) {
+        const actor = claudeActor({
+          text: prompt,
+          isSidechain: ev.isSidechain,
+          userType: ev.userType ?? null,
+          isFirstUserTurn: !sawUserTurn
+        });
+        sawUserTurn = true;
         spans.push(
           userPromptSpan({
             traceId: ctx.traceId,
@@ -548,7 +645,8 @@ function parseClaudeStream(events, ctx) {
             service: SERVICE2,
             agent: ctx.agent,
             step,
-            content: prompt
+            content: prompt,
+            actor
           })
         );
         step += 1;
@@ -575,7 +673,7 @@ var ClaudeAdapter = class {
   harness = "claude-code";
   aliases = ["claude", "claudish", "openclaw", "nanoclaw"];
   root() {
-    return join2(homedir2(), ".claude", "projects");
+    return join3(homedir2(), ".claude", "projects");
   }
   async locate(opts = {}) {
     const root = this.root();
@@ -587,7 +685,7 @@ var ClaudeAdapter = class {
     }
     const refs = [];
     for (const dir of projectDirs) {
-      const dirPath = join2(root, dir);
+      const dirPath = join3(root, dir);
       let files;
       try {
         files = await readdir2(dirPath);
@@ -596,7 +694,7 @@ var ClaudeAdapter = class {
       }
       for (const f of files) {
         if (!f.endsWith(".jsonl")) continue;
-        const path = join2(dirPath, f);
+        const path = join3(dirPath, f);
         let st;
         try {
           st = await stat2(path);
@@ -643,7 +741,7 @@ var ClaudeAdapter = class {
   }
   /** 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");
+    const subDir = join3(ref.path.replace(/\.jsonl$/, ""), "subagents");
     let files;
     try {
       files = await readdir2(subDir);
@@ -656,13 +754,13 @@ var ClaudeAdapter = class {
       const hash = basename2(f, ".jsonl");
       let meta = {};
       try {
-        meta = JSON.parse(await readFile3(join2(subDir, `${hash}.meta.json`), "utf8"));
+        meta = JSON.parse(await readFile3(join3(subDir, `${hash}.meta.json`), "utf8"));
       } catch {
       }
       const parent = meta.toolUseId && main.toolSpanByUseId.get(meta.toolUseId)?.span_id || `root:${traceId}`;
       let raw;
       try {
-        raw = await readFile3(join2(subDir, f), "utf8");
+        raw = await readFile3(join3(subDir, f), "utf8");
       } catch {
         continue;
       }
@@ -682,7 +780,7 @@ var ClaudeAdapter = class {
 // src/adapters/codex.ts
 import { readdir as readdir3, readFile as readFile4, stat as stat3 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { basename as basename3, join as join3 } from "path";
+import { basename as basename3, join as join4 } from "path";
 var SERVICE3 = "codex";
 function parseLines2(raw) {
   const out = [];
@@ -718,7 +816,7 @@ async function* walkRollouts(root) {
     return;
   }
   for (const y of years) {
-    const yp = join3(root, y);
+    const yp = join4(root, y);
     let months;
     try {
       months = await readdir3(yp);
@@ -726,7 +824,7 @@ async function* walkRollouts(root) {
       continue;
     }
     for (const m of months) {
-      const mp = join3(yp, m);
+      const mp = join4(yp, m);
       let days;
       try {
         days = await readdir3(mp);
@@ -734,7 +832,7 @@ async function* walkRollouts(root) {
         continue;
       }
       for (const d of days) {
-        const dp = join3(mp, d);
+        const dp = join4(mp, d);
         let files;
         try {
           files = await readdir3(dp);
@@ -742,7 +840,7 @@ async function* walkRollouts(root) {
           continue;
         }
         for (const f of files) {
-          if (f.startsWith("rollout-") && f.endsWith(".jsonl")) yield join3(dp, f);
+          if (f.startsWith("rollout-") && f.endsWith(".jsonl")) yield join4(dp, f);
         }
       }
     }
@@ -752,7 +850,7 @@ var CodexAdapter = class {
   harness = "codex";
   aliases = ["codex-acp"];
   root() {
-    return process.env.CODEX_HOME ? join3(process.env.CODEX_HOME, "sessions") : join3(homedir3(), ".codex", "sessions");
+    return process.env.CODEX_HOME ? join4(process.env.CODEX_HOME, "sessions") : join4(homedir3(), ".codex", "sessions");
   }
   async locate(opts = {}) {
     const refs = [];
@@ -764,14 +862,18 @@ var CodexAdapter = class {
         continue;
       }
       if (opts.sinceMs && st.mtimeMs < opts.sinceMs) continue;
-      const head = (await readFile4(path, "utf8").catch(() => "")).split("\n", 1)[0] ?? "";
+      const head = (await readFile4(path, "utf8").catch(() => "")).split("\n", 40);
       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 {
+      for (const line of head) {
+        if (!line) continue;
+        try {
+          const l = JSON.parse(line);
+          if (l.type === "session_meta" && l.payload?.id) id = l.payload.id;
+          if (!cwd && l.payload?.cwd) cwd = l.payload.cwd;
+        } catch {
+        }
+        if (cwd) break;
       }
       if (opts.cwd && (!cwd || !cwd.startsWith(opts.cwd))) continue;
       refs.push({ harness: this.harness, sessionId: id, path, cwd, mtimeMs: st.mtimeMs });
@@ -801,6 +903,7 @@ var CodexAdapter = class {
     const toolByCallId = /* @__PURE__ */ new Map();
     let step = 0;
     let lastLlm = rootId;
+    let sawUserTurn = false;
     for (const l of lines) {
       const ts = l.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
       if (l.type === "event_msg" && l.payload?.type === "token_count") {
@@ -855,6 +958,8 @@ var CodexAdapter = class {
       } else if (l.type === "response_item" && l.payload?.type === "message" && l.payload.role === "user") {
         const prompt = textOf3(l.payload.content);
         if (prompt) {
+          const actor = codexActor({ text: prompt, isFirstUserTurn: !sawUserTurn });
+          sawUserTurn = true;
           spans.push(
             userPromptSpan({
               traceId,
@@ -864,7 +969,8 @@ var CodexAdapter = class {
               content: prompt,
               service: SERVICE3,
               agent: SERVICE3,
-              step
+              step,
+              actor
             })
           );
           step += 1;
@@ -897,7 +1003,7 @@ var CodexAdapter = class {
 // src/adapters/copilot.ts
 import { readdir as readdir4, readFile as readFile5, stat as stat4 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 var SERVICE4 = "github-copilot";
 function parseLines3(raw) {
   const out = [];
@@ -914,7 +1020,7 @@ var CopilotAdapter = class {
   harness = "github-copilot";
   aliases = ["copilot"];
   root() {
-    return join4(process.env.COPILOT_HOME ?? join4(homedir4(), ".copilot"), "session-state");
+    return join5(process.env.COPILOT_HOME ?? join5(homedir4(), ".copilot"), "session-state");
   }
   async locate(opts = {}) {
     let dirs;
@@ -925,7 +1031,7 @@ var CopilotAdapter = class {
     }
     const refs = [];
     for (const id of dirs) {
-      const path = join4(this.root(), id, "events.jsonl");
+      const path = join5(this.root(), id, "events.jsonl");
       let st;
       try {
         st = await stat4(path);
@@ -1023,7 +1129,7 @@ var CopilotAdapter = class {
 // src/adapters/factory.ts
 import { readdir as readdir5, readFile as readFile6, stat as stat5 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename4, join as join5 } from "path";
+import { basename as basename4, join as join6 } from "path";
 var SERVICE5 = "factory";
 function textOf4(content) {
   return capText(
@@ -1045,7 +1151,7 @@ var FactoryAdapter = class {
   harness = "factory";
   aliases = ["factory-droids", "droid"];
   root() {
-    return join5(homedir5(), ".factory", "sessions");
+    return join6(homedir5(), ".factory", "sessions");
   }
   async locate(opts = {}) {
     const root = this.root();
@@ -1057,7 +1163,7 @@ var FactoryAdapter = class {
     }
     const refs = [];
     for (const dir of dirs) {
-      const dp = join5(root, dir);
+      const dp = join6(root, dir);
       let files;
       try {
         files = await readdir5(dp);
@@ -1068,7 +1174,7 @@ var FactoryAdapter = class {
       if (opts.cwd && !cwd.startsWith(opts.cwd)) continue;
       for (const f of files) {
         if (!f.endsWith(".jsonl")) continue;
-        const path = join5(dp, f);
+        const path = join6(dp, f);
         let st;
         try {
           st = await stat5(path);
@@ -1184,7 +1290,7 @@ var FactoryAdapter = class {
 // src/adapters/forge.ts
 import { readdir as readdir6, readFile as readFile7, stat as stat6 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { basename as basename5, join as join6 } from "path";
+import { basename as basename5, join as join7 } from "path";
 var SERVICE6 = "forge";
 function tokens(t) {
   if (!t) return null;
@@ -1198,7 +1304,7 @@ var ForgeAdapter = class {
   aliases = ["forgecode"];
   /** Directories scanned for `*-dump.json` exports. */
   dumpDirs() {
-    return [process.cwd(), join6(homedir6(), ".forge")];
+    return [process.cwd(), join7(homedir6(), ".forge")];
   }
   async locate(opts = {}) {
     const refs = [];
@@ -1212,7 +1318,7 @@ var ForgeAdapter = class {
       }
       for (const f of files) {
         if (!f.endsWith("-dump.json")) continue;
-        const path = join6(dir, f);
+        const path = join7(dir, f);
         let st;
         try {
           st = await stat6(path);
@@ -1314,7 +1420,7 @@ var ForgeAdapter = class {
 // src/adapters/gemini.ts
 import { readdir as readdir7, readFile as readFile8, stat as stat7 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { join as join7 } from "path";
+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;
@@ -1339,7 +1445,21 @@ var GeminiFamilyAdapter = class {
     this.homeDirName = cfg.homeDirName;
   }
   chatsRoot() {
-    return join7(homedir7(), this.homeDirName, "tmp");
+    return join8(homedir7(), this.homeDirName, "tmp");
+  }
+  /** `<home>/projects.json` maps `{ <absolute-cwd>: <projectName> }`. The session
+   *  dir name (`tmp/<projectHash>/`) is that projectName for registered projects,
+   *  so inverting the map recovers cwd. (Unregistered/older dirs are opaque cwd
+   *  digests and stay null.) Loaded once per locate(). */
+  async loadProjectCwds() {
+    const nameToPath = /* @__PURE__ */ new Map();
+    try {
+      const raw = await readFile8(join8(homedir7(), this.homeDirName, "projects.json"), "utf8");
+      const projects = JSON.parse(raw).projects ?? {};
+      for (const [path, name] of Object.entries(projects)) nameToPath.set(name, path);
+    } catch {
+    }
+    return nameToPath;
   }
   async locate(opts = {}) {
     const root = this.chatsRoot();
@@ -1349,9 +1469,11 @@ var GeminiFamilyAdapter = class {
     } catch {
       return [];
     }
+    const projectCwds = await this.loadProjectCwds();
     const refs = [];
     for (const pd of projectDirs) {
-      const chatsDir = join7(root, pd, "chats");
+      const cwd = projectCwds.get(pd) ?? null;
+      const chatsDir = join8(root, pd, "chats");
       let files;
       try {
         files = await readdir7(chatsDir);
@@ -1360,7 +1482,7 @@ var GeminiFamilyAdapter = class {
       }
       for (const f of files) {
         if (!f.startsWith("session-") || !f.endsWith(".json")) continue;
-        const path = join7(chatsDir, f);
+        const path = join8(chatsDir, f);
         let st;
         try {
           st = await stat7(path);
@@ -1368,8 +1490,8 @@ var GeminiFamilyAdapter = class {
           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 });
+        if (opts.cwd && (!cwd || !cwd.startsWith(opts.cwd))) continue;
+        refs.push({ harness: this.harness, sessionId: f.replace(/\.json$/, ""), path, cwd, mtimeMs: st.mtimeMs });
       }
     }
     return refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -1473,7 +1595,7 @@ var GeminiAdapter = class extends GeminiFamilyAdapter {
 // src/adapters/opencode.ts
 import { readdir as readdir8, readFile as readFile9, stat as stat8 } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var SERVICE7 = "opencode";
 function isoOf(ms) {
   return new Date(ms ?? 0).toISOString();
@@ -1486,11 +1608,11 @@ function textOf7(parts) {
 var OpencodeAdapter = class {
   harness = "opencode";
   storage() {
-    const base = process.env.XDG_DATA_HOME ?? join8(homedir8(), ".local", "share");
-    return join8(base, "opencode", "storage");
+    const base = process.env.XDG_DATA_HOME ?? join9(homedir8(), ".local", "share");
+    return join9(base, "opencode", "storage");
   }
   async locate(opts = {}) {
-    const msgRoot = join8(this.storage(), "message");
+    const msgRoot = join9(this.storage(), "message");
     let sessionDirs;
     try {
       sessionDirs = await readdir8(msgRoot);
@@ -1499,7 +1621,7 @@ var OpencodeAdapter = class {
     }
     const refs = [];
     for (const sid of sessionDirs) {
-      const dir = join8(msgRoot, sid);
+      const dir = join9(msgRoot, sid);
       let st;
       try {
         st = await stat8(dir);
@@ -1516,7 +1638,7 @@ var OpencodeAdapter = class {
   async parse(ref) {
     const traceId = ref.sessionId;
     const rootId = `root:${traceId}`;
-    const partRoot = join8(this.storage(), "part");
+    const partRoot = join9(this.storage(), "part");
     let msgFiles;
     try {
       msgFiles = (await readdir8(ref.path)).filter((f) => f.endsWith(".json"));
@@ -1526,7 +1648,7 @@ var OpencodeAdapter = class {
     const messages = [];
     for (const f of msgFiles) {
       try {
-        messages.push({ msg: JSON.parse(await readFile9(join8(ref.path, f), "utf8")), file: f });
+        messages.push({ msg: JSON.parse(await readFile9(join9(ref.path, f), "utf8")), file: f });
       } catch {
       }
     }
@@ -1548,13 +1670,13 @@ var OpencodeAdapter = class {
     for (const { msg } of messages) {
       const mid = msg.id ?? `m${step}`;
       const llmId = `llm:${mid}`;
-      const pdir = join8(partRoot, mid);
+      const pdir = join9(partRoot, mid);
       const parts = [];
       try {
         const partFiles = (await readdir8(pdir)).filter((f) => f.endsWith(".json"));
         for (const pf of partFiles) {
           try {
-            parts.push(JSON.parse(await readFile9(join8(pdir, pf), "utf8")));
+            parts.push(JSON.parse(await readFile9(join9(pdir, pf), "utf8")));
           } catch {
           }
         }
@@ -1626,7 +1748,7 @@ var OpencodeAdapter = class {
 // src/adapters/pi.ts
 import { readdir as readdir9, readFile as readFile10, stat as stat9 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { basename as basename6, join as join9 } from "path";
+import { basename as basename6, join as join10 } from "path";
 var SERVICE8 = "pi";
 function parseLines5(raw) {
   const out = [];
@@ -1654,7 +1776,7 @@ function textOf8(content) {
 var PiAdapter = class {
   harness = "pi";
   root() {
-    return join9(homedir9(), ".pi", "agent", "sessions");
+    return join10(homedir9(), ".pi", "agent", "sessions");
   }
   async locate(opts = {}) {
     const root = this.root();
@@ -1666,7 +1788,7 @@ var PiAdapter = class {
     }
     const refs = [];
     for (const dir of dirs) {
-      const dp = join9(root, dir);
+      const dp = join10(root, dir);
       let files;
       try {
         files = await readdir9(dp);
@@ -1677,7 +1799,7 @@ var PiAdapter = class {
       if (opts.cwd && !cwd.startsWith(opts.cwd)) continue;
       for (const f of files) {
         if (!f.endsWith(".jsonl")) continue;
-        const path = join9(dp, f);
+        const path = join10(dp, f);
         let st;
         try {
           st = await stat9(path);
@@ -1795,7 +1917,7 @@ var PiAdapter = class {
 // src/adapters/qwen.ts
 import { readdir as readdir10, readFile as readFile11, stat as stat10 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { basename as basename7, join as join10 } from "path";
+import { basename as basename7, join as join11 } from "path";
 var SERVICE9 = "qwen";
 function parseLines6(raw) {
   const out = [];
@@ -1816,7 +1938,7 @@ var QwenAdapter = class {
   harness = "qwen";
   aliases = ["qwen-code"];
   root() {
-    return join10(homedir10(), ".qwen", "projects");
+    return join11(homedir10(), ".qwen", "projects");
   }
   async locate(opts = {}) {
     const root = this.root();
@@ -1828,7 +1950,7 @@ var QwenAdapter = class {
     }
     const refs = [];
     for (const pd of projectDirs) {
-      const chatsDir = join10(root, pd, "chats");
+      const chatsDir = join11(root, pd, "chats");
       let files;
       try {
         files = await readdir10(chatsDir);
@@ -1838,7 +1960,7 @@ var QwenAdapter = class {
       if (opts.cwd) continue;
       for (const f of files) {
         if (!f.endsWith(".jsonl")) continue;
-        const path = join10(chatsDir, f);
+        const path = join11(chatsDir, f);
         let st;
         try {
           st = await stat10(path);
@@ -1988,7 +2110,279 @@ function selectAdapters(opts) {
   });
 }
 
+// src/repo.ts
+import { stat as stat11 } from "fs/promises";
+import { dirname, isAbsolute, join as join12, normalize, parse as parsePath } from "path";
+function normalizeRemote(url) {
+  const raw = url.trim();
+  if (!raw) return null;
+  const url2 = raw.match(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/(.+)$/);
+  if (url2) {
+    let rest = url2[1];
+    const at = rest.lastIndexOf("@");
+    if (at !== -1) rest = rest.slice(at + 1);
+    rest = rest.replace(/\.git$/, "").replace(/\/+$/g, "");
+    const slash = rest.indexOf("/");
+    if (slash === -1) return null;
+    const host = rest.slice(0, slash).replace(/:\d+$/, "");
+    const path = rest.slice(slash + 1).replace(/^\/+/, "");
+    return host && path ? `${host}/${path}` : null;
+  }
+  const scp = raw.match(/^[^@/]+@([^:/]+):(.+)$/);
+  if (scp) {
+    const path = scp[2].replace(/\.git$/, "").replace(/^\/+|\/+$/g, "");
+    return path ? `${scp[1]}/${path}` : null;
+  }
+  return null;
+}
+async function readGit(cwd) {
+  await stat11(`${cwd}/.git`);
+  const { execFile } = await import("child_process");
+  const { promisify } = await import("util");
+  const run = promisify(execFile);
+  const git = async (args) => {
+    try {
+      const { stdout } = await run("git", ["-C", cwd, ...args], { timeout: 5e3 });
+      const v = stdout.trim();
+      return v.length > 0 ? v : null;
+    } catch {
+      return null;
+    }
+  };
+  let remote = await git(["remote", "get-url", "origin"]);
+  if (!remote) {
+    const first = await git(["remote"]);
+    const name = first?.split("\n")[0]?.trim();
+    if (name) remote = await git(["remote", "get-url", name]);
+  }
+  const branch = await git(["rev-parse", "--abbrev-ref", "HEAD"]);
+  const commit = await git(["rev-parse", "--short", "HEAD"]);
+  return {
+    remote,
+    branch: branch === "HEAD" ? null : branch,
+    // detached HEAD → no branch name
+    commit
+  };
+}
+async function pathStat(path) {
+  try {
+    return await stat11(path);
+  } catch {
+    return null;
+  }
+}
+async function directoryExists(path) {
+  const s = await pathStat(path);
+  return Boolean(s?.isDirectory());
+}
+async function nearestExistingDir(path) {
+  if (!path || !isAbsolute(path)) return null;
+  let cur = normalize(path);
+  for (; ; ) {
+    const s = await pathStat(cur);
+    if (s?.isDirectory()) return cur;
+    if (s?.isFile()) return dirname(cur);
+    const parent = dirname(cur);
+    if (parent === cur) return null;
+    cur = parent;
+  }
+}
+async function findGitRoot(path) {
+  let cur = await nearestExistingDir(path);
+  while (cur) {
+    if (await pathStat(join12(cur, ".git"))) return cur;
+    const parent = dirname(cur);
+    if (parent === cur) return null;
+    cur = parent;
+  }
+  return null;
+}
+async function repairDashedPath(cwd) {
+  if (!isAbsolute(cwd) || await directoryExists(cwd)) return null;
+  const normalized = normalize(cwd);
+  const parsed = parsePath(normalized);
+  const parts = normalized.slice(parsed.root.length).split("/").filter(Boolean);
+  if (parts.length === 0) return null;
+  let current = parsed.root;
+  let index = 0;
+  while (index < parts.length) {
+    const nextPart = parts[index];
+    if (!nextPart) break;
+    const exact = join12(current, nextPart);
+    if (!await directoryExists(exact)) break;
+    current = exact;
+    index += 1;
+  }
+  while (index < parts.length) {
+    let match = null;
+    let consumed = 0;
+    for (let n = parts.length - index; n >= 1; n -= 1) {
+      const segment = parts.slice(index, index + n).join("-");
+      const candidate = join12(current, segment);
+      if (await directoryExists(candidate)) {
+        match = candidate;
+        consumed = n;
+        break;
+      }
+    }
+    if (!match) return null;
+    current = match;
+    index += consumed;
+  }
+  return current !== normalized ? current : null;
+}
+var ABSOLUTE_PATH_RE = /\/(?:home|tmp|private\/tmp|Users|work|workspace|workspaces|mnt|srv|var|opt|repo|app)\/[^\s"'`<>|;]+/g;
+var MAX_SPAN_PATH_CANDIDATES = 64;
+var MAX_SPAN_TEXT_CHARS = 2e5;
+var SOURCE_WEIGHT = {
+  none: 0,
+  "span-path": 5,
+  "ref-cwd": 50,
+  "repaired-cwd": 90,
+  "span-workdir": 100
+};
+function cleanPathCandidate(raw) {
+  let value = raw.trim().replace(/\\n/g, "").replace(/[),\].}]+$/g, "").replace(/:\d+(?::\d+)?$/g, "");
+  value = normalize(value);
+  return isAbsolute(value) ? value : null;
+}
+function looksLikeWorkdirKey(key) {
+  return key === "cwd" || key === "workdir" || key === "workingDirectory" || key === "working_directory";
+}
+function* pathEvidenceFromText(text, source) {
+  if (source === "span-workdir") {
+    const direct = cleanPathCandidate(text);
+    if (direct) yield { path: direct, source, weight: SOURCE_WEIGHT[source] };
+  }
+  for (const match of text.matchAll(ABSOLUTE_PATH_RE)) {
+    const candidate = cleanPathCandidate(match[0]);
+    if (candidate) yield { path: candidate, source: "span-path", weight: SOURCE_WEIGHT["span-path"] };
+  }
+}
+function* pathsFromUnknown(value, key, depth = 0) {
+  if (depth > 4 || value == null) return;
+  if (typeof value === "string") {
+    yield* pathEvidenceFromText(value, looksLikeWorkdirKey(key) ? "span-workdir" : "span-path");
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      try {
+        yield* pathsFromUnknown(JSON.parse(trimmed), key, depth + 1);
+      } catch {
+      }
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) yield* pathsFromUnknown(item, key, depth + 1);
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [childKey, item] of Object.entries(value)) yield* pathsFromUnknown(item, childKey, depth + 1);
+  }
+}
+function extractAbsolutePaths(spans) {
+  const paths = [];
+  const seen = /* @__PURE__ */ new Set();
+  let scannedChars = 0;
+  for (const span2 of spans) {
+    for (const value of [span2.name, span2.status.message, ...Object.values(span2.attributes)]) {
+      for (const evidence of pathsFromUnknown(value)) {
+        scannedChars += evidence.path.length;
+        if (scannedChars > MAX_SPAN_TEXT_CHARS) return paths;
+        const key = `${evidence.source}:${evidence.path}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        paths.push(evidence);
+        if (paths.length >= MAX_SPAN_PATH_CANDIDATES) return paths;
+      }
+    }
+  }
+  return paths;
+}
+async function resolveRepoAttrs(cwd) {
+  if (!cwd) return {};
+  const attrs = { [ATTR.CWD]: cwd };
+  const basename10 = (() => {
+    const trimmed = cwd.replace(/\/+$/g, "");
+    const idx = trimmed.lastIndexOf("/");
+    const name = idx === -1 ? trimmed : trimmed.slice(idx + 1);
+    return name || trimmed;
+  })();
+  try {
+    const gitRoot = await findGitRoot(cwd);
+    if (!gitRoot) throw new Error("no git root");
+    const { remote, branch, commit } = await readGit(gitRoot);
+    const normalized = remote ? normalizeRemote(remote) : null;
+    if (normalized) {
+      attrs[ATTR.SUBJECT_KEY] = normalized;
+      attrs[ATTR.GIT_REPOSITORY] = normalized;
+      if (branch) attrs[ATTR.GIT_BRANCH_NAME] = branch;
+      if (commit) attrs[ATTR.GIT_COMMIT] = commit;
+      return attrs;
+    }
+    if (branch) attrs[ATTR.GIT_BRANCH_NAME] = branch;
+    if (commit) attrs[ATTR.GIT_COMMIT] = commit;
+  } catch {
+  }
+  attrs[ATTR.SUBJECT_KEY] = basename10;
+  return attrs;
+}
+async function repoCandidateForPath(path) {
+  return await findGitRoot(path) ?? await nearestExistingDir(path);
+}
+async function resolveSessionRepoAttrs(cwd, spans) {
+  const candidates = /* @__PURE__ */ new Map();
+  const add = (value, source, weight = SOURCE_WEIGHT[source]) => {
+    if (!value) return;
+    const existing = candidates.get(value);
+    if (existing) {
+      existing.score += weight;
+      if (SOURCE_WEIGHT[source] > SOURCE_WEIGHT[existing.source]) existing.source = source;
+      return;
+    }
+    candidates.set(value, { cwd: value, source, score: weight, order: candidates.size });
+  };
+  if (cwd) {
+    add(await repairDashedPath(cwd), "repaired-cwd");
+    add(cwd, "ref-cwd");
+  }
+  for (const evidence of extractAbsolutePaths(spans)) {
+    add(await repoCandidateForPath(evidence.path), evidence.source, evidence.weight);
+  }
+  const resolved = [];
+  for (const candidate of candidates.values()) {
+    const attrs = await resolveRepoAttrs(candidate.cwd);
+    resolved.push({ ...candidate, attrs });
+  }
+  const byScore = (a, b) => b.score - a.score || a.order - b.order;
+  const withGit = resolved.filter((candidate) => candidate.attrs[ATTR.GIT_REPOSITORY]).sort(byScore);
+  const selected = withGit[0] ?? resolved.filter((candidate) => candidate.attrs[ATTR.SUBJECT_KEY]).sort(byScore)[0];
+  if (!selected) return { attrs: {}, cwd: null, source: "none" };
+  return {
+    attrs: { ...selected.attrs, [ATTR.REPO_RESOLUTION_SOURCE]: selected.source },
+    cwd: selected.attrs[ATTR.CWD] ?? selected.cwd,
+    source: selected.source
+  };
+}
+function stampRepoAttrs(spans, attrs) {
+  const keys = Object.keys(attrs);
+  if (keys.length === 0) return spans;
+  for (const s of spans) {
+    for (const k of keys) {
+      if (s.attributes[k] === void 0) s.attributes[k] = attrs[k];
+    }
+  }
+  return spans;
+}
+
 // src/session-source.ts
+async function parseSession(adapter, ref) {
+  const spans = await adapter.parse(ref);
+  const repo = await resolveSessionRepoAttrs(ref.cwd, spans);
+  if (repo.cwd) ref.cwd = repo.cwd;
+  stampRepoAttrs(spans, repo.attrs);
+  return spans;
+}
 async function* scanSessions(opts) {
   for (const adapter of selectAdapters(opts)) {
     if (opts.signal?.aborted) return;
@@ -2004,7 +2398,7 @@ async function* scanSessions(opts) {
       if (opts.signal?.aborted) return;
       let spans;
       try {
-        spans = await adapter.parse(ref);
+        spans = await parseSession(adapter, ref);
       } catch (err) {
         opts.onError?.(err, ref);
         continue;
@@ -2015,106 +2409,235 @@ async function* scanSessions(opts) {
   }
 }
 
-// src/observer.ts
-var sleep = (ms, signal) => new Promise((resolve) => {
-  const onAbort = () => {
-    clearTimeout(t);
-    resolve();
+// src/evidence.ts
+import { mkdtemp, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join13 } from "path";
+function stringAttr(span2, key) {
+  const value = span2.attributes[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberAttr(span2, key) {
+  const value = span2.attributes[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function spanKind(span2) {
+  return stringAttr(span2, "openinference.span.kind");
+}
+function repoFromSpans(spans) {
+  const attrs = {};
+  for (const span2 of spans) {
+    attrs.subjectKey ??= stringAttr(span2, ATTR.SUBJECT_KEY);
+    attrs.repository ??= stringAttr(span2, ATTR.GIT_REPOSITORY);
+    attrs.branch ??= stringAttr(span2, ATTR.GIT_BRANCH_NAME);
+    attrs.commit ??= stringAttr(span2, ATTR.GIT_COMMIT);
+    attrs.cwd ??= stringAttr(span2, ATTR.CWD);
+    attrs.resolutionSource ??= stringAttr(span2, ATTR.REPO_RESOLUTION_SOURCE);
+    if (attrs.subjectKey && attrs.repository && attrs.branch && attrs.commit && attrs.cwd && attrs.resolutionSource) break;
+  }
+  return attrs;
+}
+function timeBounds(spans) {
+  const times = spans.flatMap((span2) => [span2.start_time, span2.end_time]).filter((value) => value && value !== "now").sort();
+  return {
+    firstSpanAt: times[0] ?? null,
+    lastSpanAt: times[times.length - 1] ?? null
   };
-  const t = setTimeout(() => {
-    signal?.removeEventListener("abort", onAbort);
-    resolve();
-  }, ms);
-  signal?.addEventListener("abort", onAbort, { once: true });
-});
-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 seen = /* @__PURE__ */ new Map();
-  while (!opts.signal?.aborted) {
-    let sessionCount = 0;
-    for await (const { adapter, ref, spans } of scanSessions({
-      adapters: opts.adapters,
-      all: opts.all,
-      harnesses: opts.harnesses,
-      cwd: opts.cwd,
-      sinceMs: Date.now() - windowMs,
-      signal: opts.signal,
-      onError: opts.onError
-    })) {
-      let report;
-      try {
-        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);
-        }
+function summarizeTools(spans) {
+  const byTool = /* @__PURE__ */ new Map();
+  for (const span2 of spans) {
+    if (spanKind(span2) !== "TOOL") continue;
+    const name = stringAttr(span2, "tool.name") ?? span2.name.replace(/^tool\./, "");
+    const current = byTool.get(name) ?? { calls: 0, errors: 0 };
+    current.calls += 1;
+    if (span2.status.code === "ERROR") current.errors += 1;
+    byTool.set(name, current);
+  }
+  return [...byTool.entries()].map(([name, row]) => ({ name, calls: row.calls, errors: row.errors })).sort((a, b) => b.calls - a.calls || a.name.localeCompare(b.name));
+}
+async function buildPolicyEvidenceRecord(ref, spans, opts = {}) {
+  const llmSpans = spans.filter((span2) => spanKind(span2) === "LLM");
+  const toolSpans = spans.filter((span2) => spanKind(span2) === "TOOL");
+  const erroredToolCallCount = toolSpans.filter((span2) => span2.status.code === "ERROR").length;
+  const pipelines = await runPipelines(spans, { minLoopOccurrences: opts.minLoopOccurrences });
+  const loopLimit = opts.maxLoopExamples ?? 25;
+  const loopFindings = pipelines.stuckLoops.findings;
+  const { firstSpanAt, lastSpanAt } = timeBounds(spans);
+  const repo = repoFromSpans(spans);
+  return {
+    schemaVersion: 1,
+    kind: "traces.policy_evidence.session",
+    generatedAt: opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    session: {
+      harness: ref.harness,
+      sessionId: ref.sessionId,
+      path: ref.path,
+      cwd: repo.cwd ?? ref.cwd,
+      mtimeMs: ref.mtimeMs
+    },
+    repo,
+    metrics: {
+      spanCount: spans.length,
+      llmTurnCount: llmSpans.length,
+      toolCallCount: toolSpans.length,
+      erroredToolCallCount,
+      inputTokens: llmSpans.reduce((sum, span2) => sum + numberAttr(span2, "llm.input_tokens"), 0),
+      outputTokens: llmSpans.reduce((sum, span2) => sum + numberAttr(span2, "llm.output_tokens"), 0),
+      models: [...new Set(llmSpans.map((span2) => stringAttr(span2, "llm.model_name")).filter((value) => Boolean(value)))].sort(),
+      tools: summarizeTools(spans),
+      firstSpanAt,
+      lastSpanAt
+    },
+    signals: {
+      stuckLoopCount: loopFindings.length,
+      affectedRunRatio: pipelines.stuckLoops.affectedRunRatio,
+      stuckLoops: loopFindings.slice(0, loopLimit).map((finding) => ({
+        toolName: finding.toolName,
+        occurrences: finding.occurrences
+      })),
+      stuckLoopsOmitted: Math.max(0, loopFindings.length - loopLimit),
+      toolErrorRate: toolSpans.length === 0 ? 0 : erroredToolCallCount / toolSpans.length
+    },
+    provenance: {
+      source: "traces",
+      evidenceKind: "session-summary",
+      ...opts.otlpPath ? { otlpPath: opts.otlpPath } : {},
+      notCampaignCell: true,
+      note: "This is normalized coding-agent session evidence for downstream policy mining; it is not an eval campaign cell."
+    }
+  };
+}
+async function collectPolicyEvidence(opts) {
+  const records = [];
+  for await (const session of scanSessions(opts)) {
+    records.push(await buildPolicyEvidenceRecord(session.ref, session.spans, opts));
+  }
+  return records;
+}
+function serializePolicyEvidence(records) {
+  if (records.length === 0) return "";
+  return `${records.map((record) => JSON.stringify(record)).join("\n")}
+`;
+}
+async function writePolicyEvidenceFile(records, outPath) {
+  const path = outPath ?? join13(await mkdtemp(join13(tmpdir(), "traces-evidence-")), "policy-evidence.jsonl");
+  await writeFile(path, serializePolicyEvidence(records), "utf8");
+  return path;
+}
+
+// src/external.ts
+import { spawn } from "child_process";
+function runCommand(command, args = [], opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 12e4;
+  const maxBuffer = opts.maxBuffer ?? 32 * 1024 * 1024;
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn(command, [...args], { signal: opts.signal });
+    } catch (err2) {
+      reject(err2 instanceof Error ? err2 : new Error(String(err2)));
+      return;
+    }
+    let out = "";
+    let err = "";
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGKILL");
+      reject(new Error(`${command}: timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    const cap = (add, buf) => {
+      const next = buf + add;
+      if (next.length > maxBuffer) {
+        killed = true;
+        child.kill("SIGKILL");
+        clearTimeout(timer);
+        reject(new Error(`${command}: output exceeded ${maxBuffer} bytes`));
       }
-      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);
-            }
-          }
+      return next;
+    };
+    child.stdout?.on("data", (d) => {
+      out = cap(String(d), out);
+    });
+    child.stderr?.on("data", (d) => {
+      err = cap(String(d), err);
+    });
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      if (!killed) reject(e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (!killed) resolve({ stdout: out, stderr: err, code });
+    });
+    if (opts.input !== void 0) {
+      child.stdin?.on("error", () => {
+      });
+      child.stdin?.end(opts.input);
+    }
+  });
+}
+function commandAnalyzer(spec) {
+  return {
+    name: spec.name,
+    async analyze(otlpPath, opts = {}) {
+      try {
+        const res = await runCommand(spec.command, spec.args(otlpPath, opts.prompt), {
+          signal: opts.signal,
+          timeoutMs: spec.timeoutMs
+        });
+        if (res.code !== 0) {
+          return { analyzer: spec.name, ok: false, output: res.stdout, error: res.stderr.trim() || `exit ${res.code}` };
         }
+        return { analyzer: spec.name, ok: true, output: res.stdout.trim(), findings: spec.parse?.(res.stdout) };
+      } catch (e) {
+        return { analyzer: spec.name, ok: false, output: "", error: e instanceof Error ? e.message : String(e) };
       }
     }
-    try {
-      opts.onTick?.({ sessions: sessionCount });
-    } catch (err) {
-      opts.onError?.(err);
+  };
+}
+function haloAnalyzer(opts = {}) {
+  const defaultPrompt = opts.defaultPrompt ?? "diagnose";
+  return commandAnalyzer({
+    name: "halo",
+    command: opts.command ?? "halo",
+    args: (otlpPath, prompt) => {
+      const args = [otlpPath, "-p", prompt ?? defaultPrompt];
+      if (opts.model) args.push("-m", opts.model);
+      return args;
+    },
+    timeoutMs: opts.timeoutMs
+  });
+}
+function runExternalAnalyzers(otlpPath, analyzers, opts = {}) {
+  return Promise.all(analyzers.map((a) => a.analyze(otlpPath, opts)));
+}
+function commandRedactor(spec) {
+  const name = spec.name ?? spec.command;
+  return {
+    name,
+    async redactText(texts) {
+      if (texts.length === 0) return [];
+      const res = await runCommand(spec.command, spec.args ?? [], {
+        input: JSON.stringify(texts),
+        timeoutMs: spec.timeoutMs
+      });
+      if (res.code !== 0) throw new Error(`redactor ${name}: exit ${res.code}: ${res.stderr.trim()}`);
+      let parsed;
+      try {
+        parsed = JSON.parse(res.stdout);
+      } catch {
+        throw new Error(`redactor ${name}: stdout was not JSON`);
+      }
+      if (!Array.isArray(parsed) || parsed.length !== texts.length) {
+        throw new Error(`redactor ${name}: expected a JSON array of ${texts.length} strings`);
+      }
+      return parsed.map(String);
     }
-    if (opts.signal?.aborted) break;
-    await sleep(intervalMs, opts.signal);
-  }
+  };
 }
 
-// src/attributes.ts
-var ATTR = {
-  /** = the trace/session id. Wire contract (dedup linkage). */
-  SESSION_ID: "tangle.sessionId",
-  /** "cli" marks a CLI upload so the platform can drop a re-upload of a session
-   *  that also streamed live. Wire contract. */
-  INGEST_SOURCE: "tangle.ingest_source",
-  HARNESS: "tangle.harness",
-  CWD: "tangle.cwd",
-  GIT_BRANCH: "tangle.git_branch",
-  HOST: "tangle.host",
-  /** Basename of the session file. (Renamed from the ambiguous `tangle.source`,
-   *  which collided with `tangle.ingest_source`.) */
-  SESSION_FILE: "tangle.session_file",
-  UPLOADED_AT: "tangle.uploaded_at",
-  UPLOADER: "tangle.uploader",
-  REDACTION_VERSION: "redaction.version",
-  REDACTION_COUNT: "redaction.count"
-};
-var INGEST_SOURCE_CLI = "cli";
-var DEFAULT_HARNESS = "claude-code";
-
 // src/redact.ts
 import { DEFAULT_REDACTION_RULES, redactValue } from "@tangle-network/agent-eval/traces";
 var CODING_REDACTION_RULES = [
@@ -2175,20 +2698,1084 @@ async function applyRedactor(spans, redactor) {
   return { spans: out, changed };
 }
 
-// src/upload-state.ts
+// src/file-export.ts
 import { createHash } from "crypto";
-import { mkdir, readFile as readFile12, writeFile as writeFile2 } from "fs/promises";
+import { mkdtemp as mkdtemp2, readFile as readFile12, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join14 } from "path";
+function isObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function objectValue(value) {
+  return isObject(value) ? value : void 0;
+}
+function stableJson(value) {
+  return JSON.stringify(value, (_key, v) => {
+    if (!isObject(v)) return v;
+    return Object.keys(v).sort().reduce((acc, key) => {
+      acc[key] = v[key];
+      return acc;
+    }, {});
+  });
+}
+function hashId(value, chars = 16) {
+  return createHash("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
+}
+function isoTime(value) {
+  if (typeof value === "string") {
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? new Date(ms).toISOString() : void 0;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const ms = value < 1e10 ? value * 1e3 : value;
+    return new Date(ms).toISOString();
+  }
+  return void 0;
+}
+function firstTime(obj, keys) {
+  for (const key of keys) {
+    const value = isoTime(obj[key]);
+    if (value) return value;
+  }
+  return void 0;
+}
+function firstTimeDeep(value, keys, depth = 5) {
+  if (depth < 0) return void 0;
+  if (isObject(value)) {
+    const direct = firstTime(value, keys);
+    if (direct) return direct;
+    for (const child of Object.values(value)) {
+      const found = firstTimeDeep(child, keys, depth - 1);
+      if (found) return found;
+    }
+  } else if (Array.isArray(value)) {
+    for (const child of value) {
+      const found = firstTimeDeep(child, keys, depth - 1);
+      if (found) return found;
+    }
+  }
+  return void 0;
+}
+function copyDefined(target, entries) {
+  for (const [key, value] of Object.entries(entries)) {
+    if (value != null && value !== "") target[key] = value;
+  }
+}
+function parseJsonRows(text) {
+  const trimmed = text.trim();
+  if (!trimmed) throw new Error("input file is empty");
+  if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) return { rows: parsed };
+    if (isObject(parsed)) {
+      const events = parsed.events;
+      if (Array.isArray(events)) return { rows: events, wrapper: parsed };
+      return { rows: [parsed] };
+    }
+    throw new Error("input JSON must be an object, array, or JSONL rows");
+  }
+  return {
+    rows: trimmed.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line))
+  };
+}
+function isPolicyEvidenceRow(row) {
+  return isObject(row) && row.kind === "traces.policy_evidence.session";
+}
+function isOpenInferenceRow(row) {
+  if (!isObject(row)) return false;
+  return typeof row.trace_id === "string" && typeof row.span_id === "string" && typeof row.name === "string" && typeof row.start_time === "string" && typeof row.end_time === "string" && isObject(row.status) && isObject(row.attributes) && isObject(row.resource) && isObject(row.scope);
+}
+function eventType(row) {
+  return stringValue(row.type) ?? stringValue(row.event) ?? stringValue(row.name) ?? stringValue(row.kind);
+}
+function looksLikeSandboxEvent(row) {
+  if (!isObject(row)) return false;
+  const type = eventType(row)?.toLowerCase();
+  return type === "start" || type === "raw" || type === "result" || type === "done" || type === "error";
+}
+function detectFormat(rows, requested) {
+  if (requested !== "auto") return requested;
+  if (rows.length === 0) throw new Error("input contains no rows");
+  if (rows.every(isPolicyEvidenceRow)) return "policy-evidence";
+  if (rows.every(isOpenInferenceRow)) return "openinference";
+  if (rows.some(looksLikeSandboxEvent)) return "sandbox-events";
+  throw new Error("could not detect input format; use --format policy-evidence, sandbox-events, or openinference");
+}
+function requirePolicyEvidenceRows(rows) {
+  if (!rows.every(isPolicyEvidenceRow)) throw new Error("policy-evidence input must contain only traces.policy_evidence.session rows");
+  return rows;
+}
+function requireOpenInferenceRows(rows) {
+  if (!rows.every(isOpenInferenceRow)) throw new Error("openinference input must contain only complete OpenInference span rows");
+  return rows;
+}
+function requireObjectRows(rows) {
+  if (!rows.every(isObject)) throw new Error("sandbox-events input must contain only JSON object events");
+  return rows;
+}
+function evidenceTimeBounds(record) {
+  const sessionTime = new Date(record.session.mtimeMs).toISOString();
+  const start = record.metrics.firstSpanAt ?? record.generatedAt ?? sessionTime;
+  const end = record.metrics.lastSpanAt ?? start;
+  return { start, end };
+}
+function policyEvidenceToSpans(records) {
+  return records.map((record) => {
+    const { start, end } = evidenceTimeBounds(record);
+    const traceId = record.session.sessionId || hashId(record, 32);
+    const extra = {
+      "traces.source_format": "policy-evidence",
+      "traces.policy_evidence.schema_version": record.schemaVersion,
+      "traces.policy_evidence.kind": record.kind,
+      "traces.session.id": record.session.sessionId,
+      "traces.session.path": record.session.path,
+      "traces.session.cwd": record.session.cwd,
+      "traces.session.mtime_ms": record.session.mtimeMs,
+      "traces.metrics.span_count": record.metrics.spanCount,
+      "traces.metrics.llm_turn_count": record.metrics.llmTurnCount,
+      "traces.metrics.tool_call_count": record.metrics.toolCallCount,
+      "traces.metrics.errored_tool_call_count": record.metrics.erroredToolCallCount,
+      "traces.metrics.input_tokens": record.metrics.inputTokens,
+      "traces.metrics.output_tokens": record.metrics.outputTokens,
+      "traces.metrics.models": record.metrics.models,
+      "traces.metrics.tools": stableJson(record.metrics.tools),
+      "traces.signals.stuck_loop_count": record.signals.stuckLoopCount,
+      "traces.signals.affected_run_ratio": record.signals.affectedRunRatio,
+      "traces.signals.stuck_loops": stableJson(record.signals.stuckLoops),
+      "traces.signals.stuck_loops_omitted": record.signals.stuckLoopsOmitted,
+      "traces.signals.tool_error_rate": record.signals.toolErrorRate,
+      "traces.provenance.source": record.provenance.source,
+      "traces.provenance.evidence_kind": record.provenance.evidenceKind,
+      "traces.provenance.otlp_path": record.provenance.otlpPath,
+      [ATTR.SUBJECT_KEY]: record.repo.subjectKey,
+      [ATTR.GIT_REPOSITORY]: record.repo.repository,
+      [ATTR.GIT_BRANCH_NAME]: record.repo.branch,
+      [ATTR.GIT_COMMIT]: record.repo.commit,
+      [ATTR.CWD]: record.repo.cwd ?? record.session.cwd,
+      [ATTR.REPO_RESOLUTION_SOURCE]: record.repo.resolutionSource
+    };
+    return span({
+      traceId,
+      spanId: `policy:${hashId(record)}`,
+      parentSpanId: null,
+      name: "policy_evidence.session",
+      kind: "AGENT",
+      startTime: start,
+      endTime: end,
+      service: record.session.harness,
+      agent: "traces",
+      content: capText(stableJson({
+        session: record.session,
+        repo: record.repo,
+        metrics: record.metrics,
+        signals: record.signals,
+        provenance: record.provenance
+      })),
+      extra
+    });
+  });
+}
+function findStringKey(value, keys, depth = 4) {
+  if (depth < 0) return void 0;
+  if (isObject(value)) {
+    for (const key of keys) {
+      const found = stringValue(value[key]);
+      if (found) return found;
+    }
+    for (const child of Object.values(value)) {
+      const found = findStringKey(child, keys, depth - 1);
+      if (found) return found;
+    }
+  } else if (Array.isArray(value)) {
+    for (const child of value) {
+      const found = findStringKey(child, keys, depth - 1);
+      if (found) return found;
+    }
+  }
+  return void 0;
+}
+function eventTimestamp(row) {
+  return firstTimeDeep(row, [
+    "timestamp",
+    "start_time",
+    "startTime",
+    "startedAt",
+    "createdAt",
+    "created_at",
+    "created",
+    "time"
+  ]);
+}
+function eventEndTimestamp(row, fallback) {
+  return firstTimeDeep(row, [
+    "end_time",
+    "endTime",
+    "completedAt",
+    "completed_at",
+    "finishedAt",
+    "updatedAt",
+    "updated_at",
+    "updated"
+  ]) ?? fallback;
+}
+function eventStatus(row, type) {
+  const lowered = type.toLowerCase();
+  const errorMessage = stringValue(row.error) ?? findStringKey(row, ["error", "errorMessage", "error_message"], 3);
+  if (lowered.includes("error") || errorMessage) {
+    const message = errorMessage ?? stringValue(row.message);
+    return { status: "ERROR", ...message ? { message: capText(message) } : {} };
+  }
+  return { status: "OK" };
+}
+function eventKind(row, type) {
+  const lowered = type.toLowerCase();
+  const tool = findStringKey(row, ["tool", "toolName", "tool_name"], 4);
+  if (tool || lowered.includes("tool") || stableJson(row).includes("tool-invocation")) return { kind: "TOOL", tool };
+  if (lowered.includes("llm") || lowered === "token") return { kind: "LLM" };
+  return { kind: "CHAIN" };
+}
+function sandboxEventsToSpans(rows, wrapper) {
+  const context = wrapper ?? {};
+  const traceId = findStringKey(context, ["trace_id", "traceId", "session_id", "sessionId", "run_id", "runId"], 3) ?? findStringKey(rows, ["trace_id", "traceId", "session_id", "sessionId", "run_id", "runId"], 4) ?? `sandbox:${hashId(rows, 32)}`;
+  const service = findStringKey(context, ["service", "harness", "source"], 2) ?? "sandbox-opencode";
+  const times = rows.flatMap((row) => {
+    const time = eventTimestamp(row);
+    return time ? [time] : [];
+  }).sort();
+  const rootId = `events:${hashId({ traceId, rows: rows.length })}`;
+  const hasError = rows.some((row) => eventStatus(row, eventType(row) ?? "event").status === "ERROR");
+  const rootStart = times[0] ?? (/* @__PURE__ */ new Date(0)).toISOString();
+  const rootEnd = times[times.length - 1] ?? rootStart;
+  const spans = [
+    span({
+      traceId,
+      spanId: rootId,
+      parentSpanId: null,
+      name: "sandbox.events",
+      kind: "AGENT",
+      startTime: rootStart,
+      endTime: rootEnd,
+      status: hasError ? "ERROR" : "OK",
+      service,
+      agent: service,
+      extra: {
+        "traces.source_format": "sandbox-events",
+        "traces.event_count": rows.length
+      }
+    })
+  ];
+  let previousTime = rootStart;
+  rows.forEach((row, index) => {
+    const type = eventType(row) ?? "event";
+    const time = eventTimestamp(row) ?? previousTime;
+    previousTime = time;
+    const { status, message } = eventStatus(row, type);
+    const { kind, tool } = eventKind(row, type);
+    const name = kind === "TOOL" && tool ? `tool.${tool}` : `event.${type}`;
+    const extra = {
+      "traces.source_format": "sandbox-events",
+      "traces.event.type": type,
+      "traces.event.index": index
+    };
+    copyDefined(extra, {
+      "traces.event.id": stringValue(row.id),
+      "traces.event.raw_type": stringValue(row.type),
+      "traces.event.raw_event": stringValue(row.event)
+    });
+    spans.push(span({
+      traceId,
+      spanId: `event:${index}:${hashId(row)}`,
+      parentSpanId: rootId,
+      name,
+      kind,
+      startTime: time,
+      endTime: eventEndTimestamp(row, time),
+      status,
+      statusMessage: message,
+      service,
+      agent: service,
+      tool: kind === "TOOL" ? tool ?? type : null,
+      step: index,
+      content: capText(stableJson(row)),
+      extra
+    }));
+  });
+  return spans;
+}
+function statusCode(value) {
+  return value === "OK" || value === "ERROR" || value === "UNSET" ? value : "UNSET";
+}
+function openInferenceToSpans(rows) {
+  return rows.map((row) => {
+    const attrs = isObject(row.attributes) ? { ...row.attributes } : {};
+    const resource = objectValue(row.resource);
+    const resourceAttrs = objectValue(resource?.attributes);
+    if (resourceAttrs) copyDefined(attrs, resourceAttrs);
+    const kind = stringValue(row.kind);
+    if (kind && attrs["openinference.span.kind"] == null) attrs["openinference.span.kind"] = kind;
+    const status = objectValue(row.status);
+    const message = stringValue(status?.message);
+    return {
+      trace_id: stringValue(row.trace_id) ?? hashId(row, 32),
+      span_id: stringValue(row.span_id) ?? hashId({ row, field: "span" }),
+      parent_span_id: stringValue(row.parent_span_id) || null,
+      name: stringValue(row.name) ?? "span",
+      start_time: stringValue(row.start_time) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      end_time: stringValue(row.end_time) ?? stringValue(row.start_time) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      status: { code: statusCode(status?.code), ...message ? { message } : {} },
+      attributes: attrs
+    };
+  });
+}
+function normalizeAttributes(attributes) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(attributes ?? {})) {
+    if (!key || value == null) continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      normalized[key] = value;
+    } else if (Array.isArray(value) && value.every(
+      (item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean"
+    )) {
+      normalized[key] = value;
+    } else {
+      normalized[key] = stableJson(value);
+    }
+  }
+  return normalized;
+}
+function withExportAttributes(spans, attributes) {
+  const normalized = normalizeAttributes(attributes);
+  if (Object.keys(normalized).length === 0) return [...spans];
+  return spans.map((s) => ({ ...s, attributes: { ...s.attributes, ...normalized } }));
+}
+function exportTraceEvidenceRows(rows, opts = {}, wrapper) {
+  const format = detectFormat(rows, opts.format ?? "auto");
+  const converted = format === "policy-evidence" ? policyEvidenceToSpans(requirePolicyEvidenceRows(rows)) : format === "openinference" ? openInferenceToSpans(requireOpenInferenceRows(rows)) : sandboxEventsToSpans(requireObjectRows(rows), wrapper);
+  const spans = withExportAttributes(converted, opts.attributes);
+  if (spans.length === 0) throw new Error(`no spans exported from ${format} input`);
+  const redacted = redactSpans(spans);
+  return {
+    format,
+    spans: redacted.spans,
+    redactionCount: redacted.report.redactionCount,
+    redactionsByRule: redacted.report.byRule
+  };
+}
+function exportTraceEvidenceText(text, opts = {}) {
+  const parsed = parseJsonRows(text);
+  return exportTraceEvidenceRows(parsed.rows, opts, parsed.wrapper);
+}
+async function exportTraceEvidenceFile(inputPath, opts = {}) {
+  const text = await readFile12(inputPath, "utf8");
+  return exportTraceEvidenceText(text, { ...opts, sourcePath: inputPath });
+}
+async function writeTraceEvidenceExportFile(inputPath, outPath, opts = {}) {
+  const result = await exportTraceEvidenceFile(inputPath, opts);
+  const path = outPath ?? join14(await mkdtemp2(join14(tmpdir2(), "traces-export-")), "spans.openinference.jsonl");
+  await writeFile2(path, serializeSpans(result.spans), "utf8");
+  return { ...result, path };
+}
+
+// src/inspect.ts
+import { mkdtemp as mkdtemp3, readFile as readFile13, writeFile as writeFile3 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { basename as basename8, join as join15 } from "path";
+var severityRank = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+function allContextFiles(index) {
+  return index.context?.roots.flatMap((root) => root.files) ?? [];
+}
+function repoLabel(row) {
+  return row.repo.subjectKey ?? row.repo.repository ?? row.repo.cwd ?? row.session.cwd ?? "(repo unknown)";
+}
+function sessionLabel(row) {
+  const id = row.session.sessionId.length > 12 ? row.session.sessionId.slice(0, 12) : row.session.sessionId;
+  return `${row.session.harness}:${id} (${repoLabel(row)})`;
+}
+function pct(value) {
+  return `${(value * 100).toFixed(value >= 0.1 ? 0 : 1)}%`;
+}
+function topToolErrors(row) {
+  const tools = row.tools.filter((tool) => tool.errors > 0).sort((a, b) => b.errors - a.errors || b.calls - a.calls || a.name.localeCompare(b.name)).slice(0, 3).map((tool) => `${tool.name} ${tool.errors}/${tool.calls}`);
+  return tools.length > 0 ? tools.join(", ") : "no tool-level error breakdown";
+}
+function topLoopTools(row) {
+  const byTool = /* @__PURE__ */ new Map();
+  for (const loop of row.signals.stuckLoops) {
+    const current = byTool.get(loop.toolName) ?? { groups: 0, maxOccurrences: 0 };
+    current.groups += 1;
+    current.maxOccurrences = Math.max(current.maxOccurrences, loop.occurrences);
+    byTool.set(loop.toolName, current);
+  }
+  const loops = [...byTool.entries()].sort(([, a], [, b]) => b.groups - a.groups || b.maxOccurrences - a.maxOccurrences).slice(0, 3).map(([toolName2, stats]) => `${toolName2} ${stats.groups} group(s), max x${stats.maxOccurrences}`);
+  const suffix = row.signals.stuckLoopsOmitted > 0 ? `, +${row.signals.stuckLoopsOmitted} omitted` : "";
+  return loops.length > 0 ? `${loops.join(", ")}${suffix}` : `${row.signals.stuckLoopCount} loop(s)`;
+}
+function sortFindings(findings) {
+  return findings.sort((a, b) => severityRank[a.severity] - severityRank[b.severity] || b.impact - a.impact || a.id.localeCompare(b.id)).map((finding) => ({ ...finding }));
+}
+function contextSourceCounts(index) {
+  return { contextFiles: allContextFiles(index).length };
+}
+function addSessionFindings(index, findings) {
+  const sessions = index.sessions;
+  if (index.totals.sessions === 0) {
+    findings.push({
+      id: "index.no-sessions",
+      severity: "high",
+      area: "index",
+      title: "No sessions were indexed",
+      impact: 100,
+      evidence: ["The index contains 0 session rows."],
+      next: "Run `traces list` for the target harness, then rerun `traces index` with the right --harness, --cwd, --since, or --last."
+    });
+    return;
+  }
+  const missingRepo = sessions.filter((row) => !row.repo.subjectKey && !row.repo.repository && !row.repo.cwd && !row.session.cwd);
+  if (missingRepo.length > 0) {
+    findings.push({
+      id: "repo.missing-attribution",
+      severity: missingRepo.length / index.totals.sessions >= 0.25 ? "high" : "medium",
+      area: "repo",
+      title: `${missingRepo.length}/${index.totals.sessions} session(s) have no repo or cwd`,
+      impact: missingRepo.length,
+      evidence: missingRepo.slice(0, 5).map((row) => `${row.session.harness}:${row.session.sessionId} at ${row.session.path}`),
+      next: "Improve adapter cwd recovery or pass --cwd for explicit session files so findings can be grouped by repo.",
+      refs: missingRepo.slice(0, 5).map((row) => row.session.path)
+    });
+  }
+  const loopSessions = sessions.filter((row) => row.signals.stuckLoopCount > 0).sort((a, b) => b.signals.stuckLoopCount - a.signals.stuckLoopCount);
+  if (loopSessions.length > 0) {
+    const stuckLoops = loopSessions.reduce((sum, row) => sum + row.signals.stuckLoopCount, 0);
+    findings.push({
+      id: "session.repeated-call-loops",
+      severity: stuckLoops >= 10 || loopSessions.length / index.totals.sessions >= 0.3 ? "high" : "medium",
+      area: "session",
+      title: `Repeated tool-call loops in ${loopSessions.length}/${index.totals.sessions} session(s)`,
+      impact: stuckLoops,
+      evidence: [
+        `${stuckLoops} repeated-call loop(s) across ${loopSessions.length} session(s).`,
+        ...loopSessions.slice(0, 5).map((row) => `${sessionLabel(row)}: ${row.signals.stuckLoopCount} loop(s); ${topLoopTools(row)}`)
+      ],
+      next: "Inspect the repeated commands and results in the referenced sessions; fix the instruction or tool path that lets the same failed action repeat.",
+      refs: loopSessions.slice(0, 5).map((row) => row.session.path)
+    });
+  }
+  const errorSessions = sessions.filter((row) => row.metrics.erroredToolCallCount >= 10 || row.metrics.toolErrorRate >= 0.1).sort((a, b) => b.metrics.erroredToolCallCount - a.metrics.erroredToolCallCount || b.metrics.toolErrorRate - a.metrics.toolErrorRate);
+  if (errorSessions.length > 0) {
+    const errors = errorSessions.reduce((sum, row) => sum + row.metrics.erroredToolCallCount, 0);
+    const worstRate = Math.max(...errorSessions.map((row) => row.metrics.toolErrorRate));
+    findings.push({
+      id: "session.tool-errors",
+      severity: errors >= 50 || worstRate >= 0.3 ? "high" : "medium",
+      area: "session",
+      title: `High tool-error count/rate in ${errorSessions.length}/${index.totals.sessions} session(s)`,
+      impact: errors,
+      evidence: errorSessions.slice(0, 5).map((row) => `${sessionLabel(row)}: ${row.metrics.erroredToolCallCount}/${row.metrics.toolCallCount} tool errors (${pct(row.metrics.toolErrorRate)}); ${topToolErrors(row)}`),
+      next: "Fix the most common failing command/tool first, then rerun `traces index` to confirm the error count drops.",
+      refs: errorSessions.slice(0, 5).map((row) => row.session.path)
+    });
+  }
+  const largeSessions = sessions.map((row) => ({ row, tokens: row.metrics.inputTokens + row.metrics.outputTokens })).filter(({ tokens: tokens2 }) => tokens2 >= 5e5).sort((a, b) => b.tokens - a.tokens);
+  if (largeSessions.length > 0) {
+    const largest = largeSessions[0]?.tokens ?? 0;
+    findings.push({
+      id: "session.large-token-runs",
+      severity: largest >= 1e6 ? "medium" : "low",
+      area: "session",
+      title: `${largeSessions.length} session(s) reported at least 500k summed tokens`,
+      impact: largest,
+      evidence: largeSessions.slice(0, 5).map(({ row, tokens: tokens2 }) => `${sessionLabel(row)}: ${tokens2.toLocaleString()} reported summed tokens (${row.metrics.inputTokens.toLocaleString()} in, ${row.metrics.outputTokens.toLocaleString()} out)`),
+      next: "Check whether these sessions need shorter handoffs, smaller files, split tasks, or clearer token accounting before optimizing anything else.",
+      refs: largeSessions.slice(0, 5).map(({ row }) => row.session.path)
+    });
+  }
+}
+function addContextFindings(index, findings) {
+  const files = allContextFiles(index);
+  if (index.totals.sessions > 0 && files.length === 0) {
+    findings.push({
+      id: "context.none-indexed",
+      severity: "medium",
+      area: "context",
+      title: "No nearby repo instructions or .evolve files were indexed",
+      impact: index.totals.sessions,
+      evidence: ["The index has session rows but 0 context files."],
+      next: "Add AGENTS.md or CLAUDE.md near active repos, or ensure session cwd points at the repo so traces can join sessions to local process docs."
+    });
+    return;
+  }
+  const hasContextRoots = (index.context?.totals.roots ?? 0) > 0;
+  if (hasContextRoots && (index.context?.totals.instructionDocs ?? 0) === 0) {
+    findings.push({
+      id: "context.no-instruction-docs",
+      severity: "medium",
+      area: "context",
+      title: "Context roots exist but no AGENTS.md, CLAUDE.md, or GEMINI.md files were found",
+      impact: index.context?.totals.roots ?? 0,
+      evidence: index.context?.roots.slice(0, 5).map((root) => root.root) ?? [],
+      next: "Add a short repo-level instruction file that links to stable process docs and anti-patterns."
+    });
+  }
+  const longInstructionDocs = files.filter((file) => file.kind === "instruction-doc" && (file.lines ?? 0) >= 100 && file.markdown?.hasToc === false).sort((a, b) => (b.lines ?? 0) - (a.lines ?? 0));
+  if (longInstructionDocs.length > 0) {
+    const longest = longInstructionDocs[0]?.lines ?? 0;
+    findings.push({
+      id: "context.long-docs-without-toc",
+      severity: longest >= 200 ? "medium" : "low",
+      area: "context",
+      title: `${longInstructionDocs.length} long instruction doc(s) are missing a Contents section`,
+      impact: longest,
+      evidence: longInstructionDocs.slice(0, 5).map((file) => `${file.path}: ${file.lines ?? 0} lines, ${file.markdown?.headings ?? 0} heading(s), no Contents section`),
+      next: "Add a compact Contents section or split stable rules into linked docs/processes and docs/anti-patterns files.",
+      refs: longInstructionDocs.slice(0, 5).map((file) => file.path)
+    });
+  }
+  const longNarrativeDocs = files.filter((file) => (file.kind === "reflection" || file.kind === "handoff") && (file.lines ?? 0) >= 40 && file.markdown?.hasToc === false).sort((a, b) => (b.lines ?? 0) - (a.lines ?? 0));
+  if (longNarrativeDocs.length > 0) {
+    const longest = longNarrativeDocs[0]?.lines ?? 0;
+    findings.push({
+      id: "context.long-narrative-docs-without-toc",
+      severity: longest >= 120 ? "medium" : "low",
+      area: "context",
+      title: `${longNarrativeDocs.length} long reflection/handoff doc(s) are hard to scan`,
+      impact: longest,
+      evidence: longNarrativeDocs.slice(0, 5).map((file) => `${file.path}: ${file.lines ?? 0} lines, ${file.markdown?.headings ?? 0} heading(s), no Contents section`),
+      next: "Put the decision, evidence, and next action at the top; add Contents only when the note is long enough to revisit.",
+      refs: longNarrativeDocs.slice(0, 5).map((file) => file.path)
+    });
+  }
+  const invalidJsonlFiles = files.filter((file) => (file.jsonl?.invalidRows ?? 0) > 0).sort((a, b) => (b.jsonl?.invalidRows ?? 0) - (a.jsonl?.invalidRows ?? 0));
+  if (invalidJsonlFiles.length > 0) {
+    const invalidRows = invalidJsonlFiles.reduce((sum, file) => sum + (file.jsonl?.invalidRows ?? 0), 0);
+    findings.push({
+      id: "context.invalid-jsonl",
+      severity: "high",
+      area: "context",
+      title: `${invalidRows} invalid JSONL row(s) in indexed context files`,
+      impact: invalidRows,
+      evidence: invalidJsonlFiles.slice(0, 5).map((file) => `${file.path}: ${file.jsonl?.invalidRows ?? 0}/${file.jsonl?.rows ?? 0} invalid row(s)`),
+      next: "Fix or quarantine invalid rows before mining these logs; malformed rows make downstream joins incomplete.",
+      refs: invalidJsonlFiles.slice(0, 5).map((file) => file.path)
+    });
+  }
+  const skillRunFiles = files.filter((file) => basename8(file.path) === "skill-runs.jsonl" && (file.jsonl?.rows ?? 0) > 0).map((file) => {
+    const rows = file.jsonl?.rows ?? 0;
+    const keys = file.jsonl?.keys ?? {};
+    const linkKeyCounts = {
+      transcriptPath: keys.transcriptPath ?? 0,
+      traceDir: keys.traceDir ?? 0,
+      sessionPath: keys.sessionPath ?? 0,
+      sessionId: keys.sessionId ?? 0
+    };
+    const bestLinkKeyRows = Math.max(
+      linkKeyCounts.transcriptPath,
+      linkKeyCounts.traceDir,
+      linkKeyCounts.sessionPath,
+      linkKeyCounts.sessionId
+    );
+    return { file, rows, bestLinkKeyRows, linkKeyCounts };
+  }).filter(({ rows, bestLinkKeyRows }) => bestLinkKeyRows < rows).sort((a, b) => b.rows - b.bestLinkKeyRows - (a.rows - a.bestLinkKeyRows));
+  if (skillRunFiles.length > 0) {
+    const missing = skillRunFiles.reduce((sum, row) => sum + (row.rows - row.bestLinkKeyRows), 0);
+    findings.push({
+      id: "context.skill-run-trace-links",
+      severity: skillRunFiles.some((row) => row.bestLinkKeyRows === 0) ? "medium" : "low",
+      area: "context",
+      title: `${skillRunFiles.length} skill-run file(s) have incomplete direct session-link fields`,
+      impact: missing,
+      evidence: skillRunFiles.slice(0, 5).map(({ file, rows, bestLinkKeyRows, linkKeyCounts }) => `${file.path}: best link key covers ${bestLinkKeyRows}/${rows} row(s); transcriptPath ${linkKeyCounts.transcriptPath}, traceDir ${linkKeyCounts.traceDir}, sessionPath ${linkKeyCounts.sessionPath}, sessionId ${linkKeyCounts.sessionId}`),
+      next: "Write a transcriptPath or sessionId on every skill-run row so traces can connect skill outcomes to the actual session behavior.",
+      refs: skillRunFiles.slice(0, 5).map(({ file }) => file.path)
+    });
+  }
+}
+function inspectSessionIndex(index, opts = {}) {
+  const findings = [];
+  addSessionFindings(index, findings);
+  addContextFindings(index, findings);
+  const ranked = sortFindings(findings).slice(0, opts.maxFindings ?? 25);
+  const sourceCounts = contextSourceCounts(index);
+  return {
+    schemaVersion: 1,
+    kind: "traces.inspection_report",
+    generatedAt: opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    source: {
+      indexGeneratedAt: index.generatedAt,
+      sessions: index.totals.sessions,
+      contextFiles: sourceCounts.contextFiles
+    },
+    totals: {
+      findings: ranked.length,
+      high: ranked.filter((finding) => finding.severity === "high").length,
+      medium: ranked.filter((finding) => finding.severity === "medium").length,
+      low: ranked.filter((finding) => finding.severity === "low").length
+    },
+    findings: ranked
+  };
+}
+function renderInspectionReport(report) {
+  const lines = [];
+  lines.push(
+    `traces inspect - ${report.totals.findings} finding(s) from ${report.source.sessions} session(s), ${report.source.contextFiles} context file(s)`
+  );
+  lines.push(`Index generated: ${report.source.indexGeneratedAt ?? "unknown"}`);
+  lines.push(`Report generated: ${report.generatedAt}`);
+  lines.push(`Severity totals: high ${report.totals.high}, medium ${report.totals.medium}, low ${report.totals.low}`);
+  if (report.findings.length === 0) {
+    lines.push("");
+    lines.push("No ranked findings. Keep rerunning this after larger or fresher indexes.");
+    return `${lines.join("\n")}
+`;
+  }
+  report.findings.forEach((finding, i) => {
+    lines.push("");
+    lines.push(`## ${i + 1}. [${finding.severity}] ${finding.title}`);
+    lines.push(`Area: ${finding.area}  Impact: ${finding.impact}`);
+    lines.push("Evidence:");
+    for (const item of finding.evidence) lines.push(`- ${item}`);
+    lines.push(`Next: ${finding.next}`);
+    if (finding.refs && finding.refs.length > 0) {
+      lines.push("Refs:");
+      for (const ref of finding.refs.slice(0, 5)) lines.push(`- ${ref}`);
+    }
+  });
+  return `${lines.join("\n")}
+`;
+}
+function serializeInspectionReport(report) {
+  return `${JSON.stringify(report, null, 2)}
+`;
+}
+function assertSessionIndex(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("session index file must contain a JSON object");
+  }
+  const candidate = value;
+  if (candidate.kind !== "traces.session_index" || candidate.schemaVersion !== 1 || !Array.isArray(candidate.sessions)) {
+    throw new Error("input is not a traces.session_index v1 file");
+  }
+  if (!candidate.totals || typeof candidate.totals !== "object") {
+    throw new Error("session index is missing totals");
+  }
+}
+async function readSessionIndexFile(path) {
+  const parsed = JSON.parse(await readFile13(path, "utf8"));
+  assertSessionIndex(parsed);
+  return parsed;
+}
+async function writeInspectionReportFile(report, outPath) {
+  const path = outPath ?? join15(await mkdtemp3(join15(tmpdir3(), "traces-inspect-")), "inspection-report.md");
+  await writeFile3(path, renderInspectionReport(report), "utf8");
+  return path;
+}
+
+// src/observer.ts
+var sleep = (ms, signal) => new Promise((resolve) => {
+  const onAbort = () => {
+    clearTimeout(t);
+    resolve();
+  };
+  const t = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+function loopKey(sessionId, toolName2, argHash) {
+  return `${sessionId}\0${toolName2}\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 seen = /* @__PURE__ */ new Map();
+  while (!opts.signal?.aborted) {
+    let sessionCount = 0;
+    for await (const { adapter, ref, spans } of scanSessions({
+      adapters: opts.adapters,
+      all: opts.all,
+      harnesses: opts.harnesses,
+      cwd: opts.cwd,
+      sinceMs: Date.now() - windowMs,
+      signal: opts.signal,
+      onError: opts.onError
+    })) {
+      let report;
+      try {
+        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/reactions.ts
+var REACTIONS = ["correction", "frustration", "jargon", "structure", "praise"];
+function emptySignals() {
+  return { correction: 0, frustration: 0, jargon: 0, structure: 0, praise: 0 };
+}
+function spanStep(s) {
+  const v = s.attributes.step;
+  return typeof v === "number" ? v : Number.MAX_SAFE_INTEGER;
+}
+function ordered(spans) {
+  return [...spans].sort((a, b) => {
+    const ds = spanStep(a) - spanStep(b);
+    if (ds !== 0) return ds;
+    return a.start_time.localeCompare(b.start_time);
+  });
+}
+function isAssistant(s) {
+  const kind = s.attributes["openinference.span.kind"];
+  if (s.name === "user.prompt") return false;
+  return kind === "LLM" || s.name.startsWith("message.assistant");
+}
+function isHumanPrompt(s) {
+  return s.name === "user.prompt" && s.attributes[ACTOR_ATTR] === "human";
+}
+function contentOf(s) {
+  const c = s.attributes.content;
+  return typeof c === "string" ? c : "";
+}
+var MAX_PAIRS = 10;
+function pairStrength(reactions) {
+  let n = 0;
+  for (const r of reactions) n += CORRECTIVE_REACTIONS.includes(r) ? 2 : 1;
+  return n;
+}
+function analyzeReactions(spans) {
+  const byTrace = /* @__PURE__ */ new Map();
+  for (const s of spans) {
+    const arr = byTrace.get(s.trace_id) ?? [];
+    arr.push(s);
+    byTrace.set(s.trace_id, arr);
+  }
+  const sessions = [];
+  const corpus = emptySignals();
+  let corpusTurns = 0;
+  const pairs = [];
+  for (const [sessionId, traceSpans] of byTrace) {
+    const seq = ordered(traceSpans);
+    const sessionSignals = emptySignals();
+    let humanReactionTurns = 0;
+    let lastAssistant = null;
+    for (const s of seq) {
+      if (isAssistant(s)) {
+        const text = contentOf(s);
+        if (text) lastAssistant = text;
+        continue;
+      }
+      if (!isHumanPrompt(s)) continue;
+      if (lastAssistant === null) continue;
+      humanReactionTurns += 1;
+      const reactions = classifyReaction(contentOf(s));
+      if (reactions.length > 0) {
+        for (const r of reactions) {
+          sessionSignals[r] += 1;
+          corpus[r] += 1;
+        }
+        pairs.push({ assistant: lastAssistant, human: contentOf(s), reactions, sessionId });
+      }
+      lastAssistant = null;
+    }
+    corpusTurns += humanReactionTurns;
+    sessions.push({ sessionId, humanReactionTurns, signals: sessionSignals });
+  }
+  const corrective = CORRECTIVE_REACTIONS.reduce((n, r) => n + corpus[r], 0);
+  const positive = corpus.praise;
+  const totalSignals = corrective + positive;
+  const ratio = totalSignals === 0 ? null : positive === 0 ? Number.POSITIVE_INFINITY : corrective / positive;
+  pairs.sort((a, b) => pairStrength(b.reactions) - pairStrength(a.reactions));
+  return {
+    sessions,
+    signals: corpus,
+    humanReactionTurns: corpusTurns,
+    correctiveToPositiveRatio: ratio,
+    triggerPairs: pairs.slice(0, MAX_PAIRS)
+  };
+}
+
+// src/session-index.ts
+import { mkdtemp as mkdtemp4, readdir as readdir11, readFile as readFile14, stat as stat12, writeFile as writeFile4 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { dirname as dirname2, join as join16 } from "path";
+function indexRow(record) {
+  return {
+    session: record.session,
+    repo: record.repo,
+    time: {
+      firstSpanAt: record.metrics.firstSpanAt,
+      lastSpanAt: record.metrics.lastSpanAt
+    },
+    metrics: {
+      spanCount: record.metrics.spanCount,
+      llmTurnCount: record.metrics.llmTurnCount,
+      toolCallCount: record.metrics.toolCallCount,
+      erroredToolCallCount: record.metrics.erroredToolCallCount,
+      inputTokens: record.metrics.inputTokens,
+      outputTokens: record.metrics.outputTokens,
+      toolErrorRate: record.signals.toolErrorRate
+    },
+    models: record.metrics.models,
+    tools: record.metrics.tools,
+    signals: record.signals
+  };
+}
+function uniqueSorted(values) {
+  return [...new Set([...values].filter((value) => Boolean(value)))].sort();
+}
+function buildSessionIndex(records, opts = {}) {
+  const sessions = records.map(indexRow);
+  return {
+    schemaVersion: 1,
+    kind: "traces.session_index",
+    generatedAt: opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    ...opts.selection ? { selection: opts.selection } : {},
+    totals: {
+      sessions: sessions.length,
+      spans: sessions.reduce((sum, row) => sum + row.metrics.spanCount, 0),
+      llmTurns: sessions.reduce((sum, row) => sum + row.metrics.llmTurnCount, 0),
+      toolCalls: sessions.reduce((sum, row) => sum + row.metrics.toolCallCount, 0),
+      erroredToolCalls: sessions.reduce((sum, row) => sum + row.metrics.erroredToolCallCount, 0),
+      inputTokens: sessions.reduce((sum, row) => sum + row.metrics.inputTokens, 0),
+      outputTokens: sessions.reduce((sum, row) => sum + row.metrics.outputTokens, 0),
+      stuckLoopSessions: sessions.filter((row) => row.signals.stuckLoopCount > 0).length,
+      stuckLoops: sessions.reduce((sum, row) => sum + row.signals.stuckLoopCount, 0),
+      harnesses: uniqueSorted(sessions.map((row) => row.session.harness)),
+      repos: uniqueSorted(sessions.map((row) => row.repo.subjectKey ?? row.repo.repository ?? row.repo.cwd ?? row.session.cwd ?? void 0)),
+      models: uniqueSorted(sessions.flatMap((row) => row.models)),
+      tools: uniqueSorted(sessions.flatMap((row) => row.tools.map((tool) => tool.name)))
+    },
+    ...opts.context ? { context: opts.context } : {},
+    sessions
+  };
+}
+async function pathStat2(path) {
+  try {
+    return await stat12(path);
+  } catch {
+    return null;
+  }
+}
+async function fileExists(path) {
+  return Boolean((await pathStat2(path))?.isFile());
+}
+async function dirExists(path) {
+  return Boolean((await pathStat2(path))?.isDirectory());
+}
+async function findContextRoot(cwd) {
+  if (!cwd) return null;
+  let current = cwd;
+  const s = await pathStat2(current);
+  if (!s) return null;
+  if (!s.isDirectory()) current = dirname2(current);
+  for (; ; ) {
+    if (await pathStat2(join16(current, ".git")) || await dirExists(join16(current, ".evolve")) || await fileExists(join16(current, "AGENTS.md")) || await fileExists(join16(current, "CLAUDE.md"))) {
+      return current;
+    }
+    const parent = dirname2(current);
+    if (parent === current) return s.isDirectory() ? cwd : dirname2(cwd);
+    current = parent;
+  }
+}
+function countLines(text) {
+  if (text.length === 0) return 0;
+  return text.endsWith("\n") ? text.split("\n").length - 1 : text.split("\n").length;
+}
+function summarizeMarkdown(text) {
+  const lines = text.split("\n");
+  return {
+    headings: lines.filter((line) => /^#{1,6}\s+\S/.test(line)).length,
+    hasToc: /\btable of contents\b/i.test(text) || /^\s*-\s+\[[^\]]+\]\(#[^)]+\)/m.test(text)
+  };
+}
+function summarizeJsonl(text) {
+  const keys = {};
+  let rows = 0;
+  let invalidRows = 0;
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    rows += 1;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        for (const key of Object.keys(parsed)) keys[key] = (keys[key] ?? 0) + 1;
+      }
+    } catch {
+      invalidRows += 1;
+    }
+  }
+  return { rows, invalidRows, keys: Object.fromEntries(Object.entries(keys).sort(([a], [b]) => a.localeCompare(b))) };
+}
+async function summarizeFile(path, kind) {
+  const s = await pathStat2(path);
+  if (!s?.isFile()) return null;
+  const base = { kind, path, bytes: Number(s.size), mtimeMs: Number(s.mtimeMs) };
+  if (!path.endsWith(".md") && !path.endsWith(".jsonl")) return base;
+  try {
+    const text = await readFile14(path, "utf8");
+    const lines = countLines(text);
+    const jsonl = path.endsWith(".jsonl") ? summarizeJsonl(text) : void 0;
+    return {
+      ...base,
+      lines,
+      ...path.endsWith(".md") ? { markdown: summarizeMarkdown(text) } : {},
+      ...jsonl ? { jsonlRows: jsonl.rows, jsonl } : {}
+    };
+  } catch {
+    return base;
+  }
+}
+async function walkMarkdown(root, kind, maxFiles = 100) {
+  const out = [];
+  async function walk(dir) {
+    if (out.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = await readdir11(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (out.length >= maxFiles) return;
+      const path = join16(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(path);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const summary = await summarizeFile(path, kind);
+        if (summary) out.push(summary);
+      }
+    }
+  }
+  await walk(root);
+  return out;
+}
+async function collectContextRoot(root) {
+  const files = [];
+  for (const name of ["AGENTS.md", "CLAUDE.md", "GEMINI.md"]) {
+    const summary = await summarizeFile(join16(root, name), "instruction-doc");
+    if (summary) files.push(summary);
+  }
+  const evolve = join16(root, ".evolve");
+  for (const name of ["skill-runs.jsonl", "governor.jsonl", "experiments.jsonl"]) {
+    const summary = await summarizeFile(join16(evolve, name), "evolve-jsonl");
+    if (summary) files.push(summary);
+  }
+  for (const name of ["scorecard.json"]) {
+    const summary = await summarizeFile(join16(evolve, name), "evolve-json");
+    if (summary) files.push(summary);
+  }
+  files.push(...await walkMarkdown(join16(evolve, "reflections"), "reflection"));
+  files.push(...await walkMarkdown(join16(evolve, "handoffs"), "handoff"));
+  return { root, files: files.sort((a, b) => a.path.localeCompare(b.path)) };
+}
+async function collectContextIndex(records) {
+  const rootSet = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    const root = await findContextRoot(record.repo.cwd ?? record.session.cwd);
+    if (root) rootSet.add(root);
+  }
+  const roots = await Promise.all([...rootSet].sort().map(collectContextRoot));
+  const files = roots.flatMap((root) => root.files);
+  return {
+    totals: {
+      roots: roots.length,
+      files: files.length,
+      instructionDocs: files.filter((file) => file.kind === "instruction-doc").length,
+      evolveFiles: files.filter((file) => file.kind.startsWith("evolve-")).length,
+      jsonlRows: files.reduce((sum, file) => sum + (file.jsonlRows ?? 0), 0),
+      invalidJsonlRows: files.reduce((sum, file) => sum + (file.jsonl?.invalidRows ?? 0), 0)
+    },
+    roots
+  };
+}
+async function buildSessionIndexFromRows(rows, opts = {}) {
+  const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const records = await Promise.all(rows.map(
+    (row) => buildPolicyEvidenceRecord(row.ref, row.spans, {
+      generatedAt,
+      minLoopOccurrences: opts.minLoopOccurrences
+    })
+  ));
+  const context = opts.includeContext === false ? void 0 : await collectContextIndex(records);
+  return buildSessionIndex(records, { ...opts, generatedAt, context });
+}
+async function collectSessionIndex(opts = {}) {
+  const rows = [];
+  for await (const session of scanSessions(opts)) {
+    rows.push({ ref: session.ref, spans: session.spans });
+  }
+  return buildSessionIndexFromRows(rows, opts);
+}
+function serializeSessionIndex(index) {
+  return `${JSON.stringify(index, null, 2)}
+`;
+}
+async function writeSessionIndexFile(index, outPath) {
+  const path = outPath ?? join16(await mkdtemp4(join16(tmpdir4(), "traces-index-")), "session-index.json");
+  await writeFile4(path, serializeSessionIndex(index), "utf8");
+  return path;
+}
+
+// src/upload-state.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdir, readFile as readFile15, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { dirname, join as join11 } from "path";
+import { dirname as dirname3, join as join17 } from "path";
 function stateFile() {
-  const base = process.env.XDG_STATE_HOME ?? join11(homedir11(), ".local", "state");
-  return join11(base, "tangle-traces", "uploaded.json");
+  const base = process.env.XDG_STATE_HOME ?? join17(homedir11(), ".local", "state");
+  return join17(base, "tangle-traces", "uploaded.json");
 }
 function uploadKey(harness, sessionId) {
   return `${harness}:${sessionId}`;
 }
 function sessionHash(spans) {
-  const h = createHash("sha256");
+  const h = createHash2("sha256");
   for (const s of spans) {
     h.update(`${s.span_id}\0${s.name}\0${s.start_time}\0${s.status.code}
 `);
@@ -2197,15 +3784,15 @@ function sessionHash(spans) {
 }
 async function loadState() {
   try {
-    return JSON.parse(await readFile12(stateFile(), "utf8"));
+    return JSON.parse(await readFile15(stateFile(), "utf8"));
   } catch {
     return {};
   }
 }
 async function saveState(state) {
   const f = stateFile();
-  await mkdir(dirname(f), { recursive: true });
-  await writeFile2(f, `${JSON.stringify(state, null, 2)}
+  await mkdir(dirname3(f), { recursive: true });
+  await writeFile5(f, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
 function alreadyUploaded(state, harness, sessionId, hash) {
@@ -2213,10 +3800,10 @@ function alreadyUploaded(state, harness, sessionId, hash) {
 }
 
 // src/upload.ts
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 import { createRequire } from "module";
 import { hostname } from "os";
-import { basename as basename8, join as join12 } from "path";
+import { basename as basename9, join as join18 } 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);
@@ -2240,7 +3827,7 @@ async function planUpload(opts = {}) {
 async function gitBranch(cwd) {
   if (!cwd) return void 0;
   try {
-    const head = await readFile13(join12(cwd, ".git", "HEAD"), "utf8");
+    const head = await readFile16(join18(cwd, ".git", "HEAD"), "utf8");
     const m = head.match(/^ref:\s*refs\/heads\/(.+)$/m);
     return m?.[1]?.trim();
   } catch {
@@ -2250,7 +3837,7 @@ async function gitBranch(cwd) {
 async function sessionMeta(item, uploadedAt) {
   const meta = {
     [ATTR.HARNESS]: item.ref.harness,
-    [ATTR.SESSION_FILE]: basename8(item.ref.path),
+    [ATTR.SESSION_FILE]: basename9(item.ref.path),
     [ATTR.HOST]: hostname(),
     [ATTR.UPLOADED_AT]: uploadedAt,
     [ATTR.UPLOADER]: `tangle-traces@${TRACES_VERSION}`,
@@ -2348,25 +3935,31 @@ async function executeUpload(plan, opts = {}) {
 }
 
 export {
+  countSkillRunsJsonl,
+  analyzeAdoption,
   span,
   toOpenInferenceSpan,
   serializeSpans,
   writeOtlpFile,
   analyzeSpans,
-  runCommand,
-  commandAnalyzer,
-  toCanonicalOpenInference,
-  haloAnalyzer,
-  runExternalAnalyzers,
-  commandRedactor,
+  ATTR,
+  INGEST_SOURCE_CLI,
+  DEFAULT_HARNESS,
   parseIsoToEpochMs,
   parseSince,
   toRuntimeStore,
   runPipelines,
   CONTENT_CAP,
   capText,
+  ACTOR_ATTR,
   userPromptSpan,
   AmpAdapter,
+  textIsSynthetic,
+  looksLikeAgentPrompt,
+  claudeActor,
+  codexActor,
+  classifyReaction,
+  CORRECTIVE_REACTIONS,
   ClaudeAdapter,
   CodexAdapter,
   CopilotAdapter,
@@ -2380,15 +3973,42 @@ export {
   resolveAdapter,
   knownHarnesses,
   selectAdapters,
+  normalizeRemote,
+  resolveRepoAttrs,
+  resolveSessionRepoAttrs,
+  stampRepoAttrs,
+  parseSession,
   scanSessions,
-  watchSessions,
-  ATTR,
-  INGEST_SOURCE_CLI,
-  DEFAULT_HARNESS,
+  buildPolicyEvidenceRecord,
+  collectPolicyEvidence,
+  serializePolicyEvidence,
+  writePolicyEvidenceFile,
+  runCommand,
+  commandAnalyzer,
+  haloAnalyzer,
+  runExternalAnalyzers,
+  commandRedactor,
   CODING_REDACTION_RULES,
   TRACES_REDACTION_RULES,
   redactSpans,
   applyRedactor,
+  exportTraceEvidenceRows,
+  exportTraceEvidenceText,
+  exportTraceEvidenceFile,
+  writeTraceEvidenceExportFile,
+  inspectSessionIndex,
+  renderInspectionReport,
+  serializeInspectionReport,
+  readSessionIndexFile,
+  writeInspectionReportFile,
+  watchSessions,
+  REACTIONS,
+  analyzeReactions,
+  buildSessionIndex,
+  buildSessionIndexFromRows,
+  collectSessionIndex,
+  serializeSessionIndex,
+  writeSessionIndexFile,
   uploadKey,
   sessionHash,
   loadState,