@tangle-network/traces 0.7.0 → 0.8.5

package/dist/{chunk-Q56AP2EY.js → chunk-D5OMTM4S.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 = {
@@ -25,17 +132,39 @@ function span(input) {
     attributes
   };
 }
+function toOpenInferenceSpan(s) {
+  const a = s.attributes;
+  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"]) {
+    if (a[k] != null) resourceAttrs[k] = a[k];
+  }
+  return {
+    trace_id: s.trace_id,
+    span_id: s.span_id,
+    parent_span_id: s.parent_span_id ?? "",
+    name: s.name,
+    kind: typeof a["openinference.span.kind"] === "string" ? a["openinference.span.kind"] : "CHAIN",
+    start_time: s.start_time,
+    end_time: s.end_time,
+    status: { code: s.status.code, message: s.status.message ?? "" },
+    resource: { attributes: resourceAttrs },
+    scope: { name: "tangle-traces", version: "" },
+    attributes: a
+  };
+}
 function serializeSpans(spans) {
   if (spans.length === 0) return "";
-  return `${spans.map((s) => JSON.stringify(s)).join("\n")}
+  return `${spans.map((s) => JSON.stringify(toOpenInferenceSpan(s))).join("\n")}
 `;
 }
 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: mkdtemp3, writeFile: writeFile4 } = await import("fs/promises");
+  const { tmpdir: tmpdir3 } = await import("os");
+  const { join: join16 } = await import("path");
+  const path = outPath ?? join16(await mkdtemp3(join16(tmpdir3(), "traces-")), "spans.otlp.jsonl");
+  await writeFile4(path, serializeSpans(spans), "utf8");
   return path;
 }
 
@@ -70,150 +199,37 @@ 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",
+  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) {
@@ -291,6 +307,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,
@@ -302,14 +319,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);
@@ -320,8 +338,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;
@@ -333,7 +351,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);
@@ -432,10 +450,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 = [];
@@ -473,6 +579,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}`;
@@ -520,6 +627,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,
@@ -529,7 +643,8 @@ function parseClaudeStream(events, ctx) {
             service: SERVICE2,
             agent: ctx.agent,
             step,
-            content: prompt
+            content: prompt,
+            actor
           })
         );
         step += 1;
@@ -556,7 +671,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();
@@ -568,7 +683,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);
@@ -577,7 +692,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);
@@ -624,7 +739,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);
@@ -637,13 +752,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;
       }
@@ -663,7 +778,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 = [];
@@ -699,7 +814,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);
@@ -707,7 +822,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);
@@ -715,7 +830,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);
@@ -723,7 +838,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);
         }
       }
     }
@@ -733,7 +848,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 = [];
@@ -782,6 +897,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") {
@@ -836,6 +952,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,
@@ -845,7 +963,8 @@ var CodexAdapter = class {
               content: prompt,
               service: SERVICE3,
               agent: SERVICE3,
-              step
+              step,
+              actor
             })
           );
           step += 1;
@@ -878,7 +997,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 = [];
@@ -895,7 +1014,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;
@@ -906,7 +1025,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);
@@ -1004,7 +1123,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(
@@ -1026,7 +1145,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();
@@ -1038,7 +1157,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);
@@ -1049,7 +1168,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);
@@ -1165,7 +1284,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;
@@ -1179,7 +1298,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 = [];
@@ -1193,7 +1312,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);
@@ -1295,7 +1414,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;
@@ -1320,7 +1439,7 @@ var GeminiFamilyAdapter = class {
     this.homeDirName = cfg.homeDirName;
   }
   chatsRoot() {
-    return join7(homedir7(), this.homeDirName, "tmp");
+    return join8(homedir7(), this.homeDirName, "tmp");
   }
   async locate(opts = {}) {
     const root = this.chatsRoot();
@@ -1332,7 +1451,7 @@ var GeminiFamilyAdapter = class {
     }
     const refs = [];
     for (const pd of projectDirs) {
-      const chatsDir = join7(root, pd, "chats");
+      const chatsDir = join8(root, pd, "chats");
       let files;
       try {
         files = await readdir7(chatsDir);
@@ -1341,7 +1460,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);
@@ -1454,7 +1573,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();
@@ -1467,11 +1586,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);
@@ -1480,7 +1599,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);
@@ -1497,7 +1616,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"));
@@ -1507,7 +1626,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 {
       }
     }
@@ -1529,13 +1648,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 {
           }
         }
@@ -1607,7 +1726,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 = [];
@@ -1635,7 +1754,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();
@@ -1647,7 +1766,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);
@@ -1658,7 +1777,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);
@@ -1776,7 +1895,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 = [];
@@ -1797,7 +1916,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();
@@ -1809,7 +1928,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);
@@ -1819,7 +1938,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);
@@ -1969,7 +2088,103 @@ function selectAdapters(opts) {
   });
 }
 
+// src/repo.ts
+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) {
+  const { stat: stat11 } = await import("fs/promises");
+  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 resolveRepoAttrs(cwd) {
+  if (!cwd) return {};
+  const attrs = { [ATTR.CWD]: cwd };
+  const basename9 = (() => {
+    const trimmed = cwd.replace(/\/+$/g, "");
+    const idx = trimmed.lastIndexOf("/");
+    const name = idx === -1 ? trimmed : trimmed.slice(idx + 1);
+    return name || trimmed;
+  })();
+  try {
+    const { remote, branch, commit } = await readGit(cwd);
+    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] = basename9;
+  return attrs;
+}
+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 repoAttrs = await resolveRepoAttrs(ref.cwd);
+  stampRepoAttrs(spans, repoAttrs);
+  return spans;
+}
 async function* scanSessions(opts) {
   for (const adapter of selectAdapters(opts)) {
     if (opts.signal?.aborted) return;
@@ -1985,7 +2200,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;
@@ -1996,106 +2211,233 @@ 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 join12 } 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);
+    if (attrs.subjectKey && attrs.repository && attrs.branch && attrs.commit && attrs.cwd) 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);
-        }
-      }
-      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);
-            }
-          }
+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);
+  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: ref.cwd,
+      mtimeMs: ref.mtimeMs
+    },
+    repo: repoFromSpans(spans),
+    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 ?? join12(await mkdtemp(join12(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`));
+      }
+      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 = [
@@ -2156,20 +2498,564 @@ 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 join13 } 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
+    };
+    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 ?? join13(await mkdtemp2(join13(tmpdir2(), "traces-export-")), "spans.openinference.jsonl");
+  await writeFile2(path, serializeSpans(result.spans), "utf8");
+  return { ...result, 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/upload-state.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdir, readFile as readFile13, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { dirname, join as join11 } from "path";
+import { dirname, join as join14 } 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 ?? join14(homedir11(), ".local", "state");
+  return join14(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}
 `);
@@ -2178,7 +3064,7 @@ function sessionHash(spans) {
 }
 async function loadState() {
   try {
-    return JSON.parse(await readFile12(stateFile(), "utf8"));
+    return JSON.parse(await readFile13(stateFile(), "utf8"));
   } catch {
     return {};
   }
@@ -2186,7 +3072,7 @@ async function loadState() {
 async function saveState(state) {
   const f = stateFile();
   await mkdir(dirname(f), { recursive: true });
-  await writeFile2(f, `${JSON.stringify(state, null, 2)}
+  await writeFile3(f, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
 function alreadyUploaded(state, harness, sessionId, hash) {
@@ -2194,10 +3080,10 @@ function alreadyUploaded(state, harness, sessionId, hash) {
 }
 
 // src/upload.ts
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile14 } from "fs/promises";
 import { createRequire } from "module";
 import { hostname } from "os";
-import { basename as basename8, join as join12 } from "path";
+import { basename as basename8, join as join15 } 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);
@@ -2221,7 +3107,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 readFile14(join15(cwd, ".git", "HEAD"), "utf8");
     const m = head.match(/^ref:\s*refs\/heads\/(.+)$/m);
     return m?.[1]?.trim();
   } catch {
@@ -2329,24 +3215,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,
@@ -2360,15 +3253,31 @@ export {
   resolveAdapter,
   knownHarnesses,
   selectAdapters,
+  normalizeRemote,
+  resolveRepoAttrs,
+  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,
+  watchSessions,
+  REACTIONS,
+  analyzeReactions,
   uploadKey,
   sessionHash,
   loadState,