evrex-mcp 0.7.0 → 0.8.1

package/dist/capture.js

@@ -9,72 +9,82 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/client.ts
-var client_exports = {};
-__export(client_exports, {
-  evrexApi: () => evrexApi
-});
-function headers() {
-  const base = { "Content-Type": "application/json" };
-  if (EVREX_TOKEN) base.Authorization = `Bearer ${EVREX_TOKEN}`;
-  return base;
+// ../../packages/ingest-core/src/types.ts
+function isReferenceKind(kind) {
+  return REFERENCE_KINDS.includes(kind ?? "");
 }
-function describeFailure(method, path, status, statusText) {
-  if (status === 401 || status === 403) {
-    return EVREX_TOKEN ? `${method} ${path} -> ${status}: the EVREX_TOKEN this server was started with was rejected. It may be revoked or expired.` : `${method} ${path} -> ${status}: this evrex backend requires a credential, but no EVREX_TOKEN is set for this MCP server.`;
-  }
-  return `${method} ${path} -> ${status} ${statusText}`;
+function lacksFileAttribution(kind) {
+  return kind === "slack" || isReferenceKind(kind);
 }
-async function request(method, path, { body, absentIsAnswer } = {}) {
-  const res = await fetch(`${API_BASE_URL}${path}`, {
-    method,
-    headers: headers(),
-    ...body === void 0 ? {} : { body: JSON.stringify(body) }
-  });
-  if (res.status === 404 && absentIsAnswer) return null;
-  if (!res.ok) throw new Error(describeFailure(method, path, res.status, res.statusText));
-  return await res.json();
+function provenanceTrailerFor(key) {
+  const k = key.toLowerCase();
+  return PROVENANCE_TRAILERS.find((t) => t.key.toLowerCase() === k);
 }
-var DEFAULT_API_BASE_URL, API_BASE_URL, EVREX_TOKEN, get, getOrNull, post, evrexApi;
-var init_client = __esm({
-  "src/client.ts"() {
+var CONVERSATION_KINDS, REFERENCE_KINDS, SOURCE_KINDS, EMPTY_USAGE, PROVENANCE_TRAILERS, STATED_TRAILERS;
+var init_types = __esm({
+  "../../packages/ingest-core/src/types.ts"() {
     "use strict";
-    DEFAULT_API_BASE_URL = "https://api.evrex.ai";
-    API_BASE_URL = (process.env.EVREX_API_BASE_URL ?? process.env.EVREX_API_URL ?? DEFAULT_API_BASE_URL).replace(/\/+$/, "");
-    EVREX_TOKEN = process.env.EVREX_TOKEN ?? process.env.EVREX_API_TOKEN ?? null;
-    get = (path) => request("GET", path);
-    getOrNull = (path) => request("GET", path, { absentIsAnswer: true });
-    post = (path, body) => request("POST", path, { body });
-    evrexApi = {
-      baseUrl: API_BASE_URL,
-      repos: () => get("/repos"),
-      commits: (repoPath) => get(`/commits?repoPath=${encodeURIComponent(repoPath)}`),
-      // Abbreviated shas resolve server-side, so a value pasted from `git log`
-      // works here (apps/backend/src/reads/reads.service.ts#resolveSha).
-      commit: (sha) => getOrNull(`/commits/${encodeURIComponent(sha)}`),
-      sessions: (repoPath) => get(`/sessions?repoPath=${encodeURIComponent(repoPath)}`),
-      session: (id) => getOrNull(`/sessions/${encodeURIComponent(id)}`),
-      // The paginated transcript — see reads.service.ts#getSessionTurns. `ts, id`
-      // ordering server-side makes offsets stable across requests.
-      sessionTurns: (id, offset, limit) => getOrNull(
-        `/sessions/${encodeURIComponent(id)}/turns?offset=${offset}&limit=${limit}`
-      ),
-      ask: (repoPath, text, filePaths) => post("/ask", { repoPath, text, filePaths }),
-      // Evidence-only retrieval (BM25 + embedding), no LLM synthesis call — see
-      // apps/backend/src/query/query.service.ts#search. Used by evrex_search,
-      // which wants ranked hits fast, not a synthesized paragraph.
-      search: (repoPath, text, filePaths) => post("/search", { repoPath, text, filePaths })
+    CONVERSATION_KINDS = [
+      "claude-code",
+      // Xcode's coding assistant — the Claude Agent SDK embedded, writing the
+      // identical transcript format under ~/Library/Developer/Xcode. A separate
+      // kind because a conversation in an IDE panel is not a CLI session, and the
+      // Slack mislabel already taught this list what an absent entry costs.
+      "claude-xcode",
+      "cursor",
+      "codex",
+      "gemini",
+      // OpenCode keeps its sessions in a SQLite store rather than files; the
+      // parser reads the store, so this kind arrives through the same importer
+      // as Cursor's.
+      "opencode",
+      // GitHub Copilot CLI writes an events file per session under ~/.copilot;
+      // the coding agent on github.com is a different thing and arrives as a
+      // reference through the Agent-Logs-Url trailer, not as this kind.
+      "copilot",
+      "slack"
+    ];
+    REFERENCE_KINDS = ["linear", "jira", "confluence"];
+    SOURCE_KINDS = [
+      ...CONVERSATION_KINDS,
+      ...REFERENCE_KINDS
+    ];
+    EMPTY_USAGE = {
+      inputTokens: null,
+      outputTokens: null,
+      cacheReadTokens: null,
+      cacheWriteTokens: null,
+      model: null
     };
+    PROVENANCE_TRAILERS = [
+      // GitHub's Copilot coding agent stamps every commit it makes with a link to
+      // its session logs (changelog, 2026-03-20). Copilot exposes no lifecycle
+      // hooks evrex could capture through, so this is the only way one of its
+      // commits ever gets a session behind it.
+      { key: "Agent-Logs-Url", agent: "copilot", label: "GitHub Copilot coding agent" },
+      // Entire's Checkpoints CLI: a checkpoint id, resolvable on entire.io or in
+      // the repo's own `refs/entire/checkpoints/` refs.
+      { key: "Entire-Checkpoint", agent: "entire", label: "Entire checkpoint" },
+      // AgentsRoom's Commit Context: the whole conversation, as an unlisted gist.
+      { key: "Agent-Conversation", agent: "agentsroom", label: "AgentsRoom conversation" }
+    ];
+    STATED_TRAILERS = [
+      { key: "Evrex-Rejected", kind: "rejected" },
+      { key: "Evrex-Constraint", kind: "constraint" },
+      { key: "Evrex-Decision", kind: "decision" }
+    ];
   }
 });
 
-// src/capture.ts
-import { statSync as statSync3 } from "node:fs";
-import { homedir as homedir2, hostname } from "node:os";
-import { join as join2 } from "node:path";
-
 // ../../packages/ingest-core/src/git-history.ts
 import { execFileSync } from "node:child_process";
+function git(repoPath, args, input) {
+  return execFileSync("git", args, {
+    cwd: repoPath,
+    maxBuffer: 1024 * 1024 * 64,
+    input
+  }).toString("utf-8");
+}
 function gitQuiet(repoPath, args) {
   return execFileSync("git", args, {
     cwd: repoPath,
@@ -116,6 +126,10 @@ function repoIdFromRootCommit(sha) {
 function repoIdFromPath(repoPath) {
   return `path:${repoPath}`;
 }
+function repoNameFromId(repoId) {
+  const withoutPrefix = repoId.replace(/^(remote|root|path):/, "");
+  return withoutPrefix.split("/").filter(Boolean).pop() ?? repoId;
+}
 function firstRemoteUrl(repoPath) {
   try {
     const origin = gitQuiet(repoPath, ["remote", "get-url", "origin"]).trim();
@@ -150,26 +164,276 @@ function deriveRepoId(repoPath) {
   if (root) return repoIdFromRootCommit(root);
   return repoIdFromPath(repoPath);
 }
+function getGitUserName(repoPath) {
+  try {
+    const name = git(repoPath, ["config", "user.name"]).trim();
+    return name || null;
+  } catch {
+    return null;
+  }
+}
+function listShas(repoPath) {
+  const out = git(repoPath, ["rev-list", "--reverse", "HEAD"]).trim();
+  return out.length ? out.split("\n") : [];
+}
+function commitMeta(repoPath, sha) {
+  const line = git(repoPath, [
+    "show",
+    "-s",
+    `--format=%H${FIELD_SEP}%an${FIELD_SEP}%ae${FIELD_SEP}%aI${FIELD_SEP}%P`,
+    sha
+  ]).trim();
+  const parts = line.split(FIELD_SEP);
+  const message = git(repoPath, ["show", "-s", "--format=%B", sha]).replace(/\n+$/, "");
+  return {
+    sha: parts[0] ?? sha,
+    author: parts[1] ?? "",
+    authorEmail: parts[2] ?? "",
+    ts: parts[3] ?? (/* @__PURE__ */ new Date()).toISOString(),
+    parents: (parts[4] ?? "").split(" ").filter(Boolean),
+    message
+  };
+}
+function parseTrailers(repoPath, message) {
+  try {
+    const out = git(
+      repoPath,
+      ["interpret-trailers", "--parse", "--no-divider"],
+      message
+    ).trim();
+    const trailers = [];
+    for (const line of out.split("\n")) {
+      const idx = line.indexOf(":");
+      if (idx === -1) continue;
+      const key = line.slice(0, idx).trim();
+      const value = line.slice(idx + 1).trim();
+      if (key && value) trailers.push({ key, value });
+    }
+    return trailers;
+  } catch {
+    return [];
+  }
+}
+function trailersFromMessage(message) {
+  const paragraphs = message.replace(/\r\n/g, "\n").trim().split(/\n{2,}/);
+  const last = paragraphs[paragraphs.length - 1] ?? "";
+  if (paragraphs.length < 2) return [];
+  const lines = last.split("\n");
+  const trailers = [];
+  for (const line of lines) {
+    const m = /^([A-Za-z][A-Za-z0-9-]*):\s+(.+?)\s*$/.exec(line);
+    if (!m) return [];
+    trailers.push({ key: m[1], value: m[2] });
+  }
+  return trailers;
+}
+function statedInsightsOf(trailers) {
+  const out = [];
+  for (const t of trailers) {
+    const known = STATED_TRAILERS.find((s) => s.key.toLowerCase() === t.key.toLowerCase());
+    if (known && t.value.trim()) out.push({ kind: known.kind, text: t.value.trim() });
+  }
+  return out;
+}
+function trailerValue(trailers, key) {
+  const k = key.toLowerCase();
+  return trailers.find((t) => t.key.toLowerCase() === k)?.value ?? null;
+}
+function originOf(trailers) {
+  const v = trailerValue(trailers, EVREX_ORIGIN_TRAILER_KEY);
+  return v?.trim().toLowerCase() === "human" ? "human" : null;
+}
+function agentTrailersOf(trailers) {
+  const out = [];
+  for (const t of trailers) {
+    const known = provenanceTrailerFor(t.key);
+    if (known) out.push({ key: known.key, value: t.value, agent: known.agent });
+  }
+  return out;
+}
+function commitBranch(repoPath, sha) {
+  try {
+    const out = git(repoPath, ["branch", "--contains", sha, "--format=%(refname:short)"]).trim();
+    const first = out.split("\n").find((b) => b.length > 0);
+    return first ?? null;
+  } catch {
+    return null;
+  }
+}
+function numstat(repoPath, sha) {
+  const out = git(repoPath, ["show", "--numstat", "--format=", sha]).trim();
+  const map = /* @__PURE__ */ new Map();
+  if (!out) return map;
+  for (const line of out.split("\n")) {
+    const [ins, del, path] = line.split("	");
+    if (!path) continue;
+    map.set(path, {
+      insertions: !ins || ins === "-" ? 0 : Number.parseInt(ins, 10) || 0,
+      deletions: !del || del === "-" ? 0 : Number.parseInt(del, 10) || 0
+    });
+  }
+  return map;
+}
+function parseDiffBlocks(diff) {
+  const map = /* @__PURE__ */ new Map();
+  if (!diff.trim()) return map;
+  const blocks = diff.split(/^diff --git /m).filter(Boolean);
+  for (const block of blocks) {
+    const full = `diff --git ${block}`;
+    const pathMatch = block.match(/^a\/(.+?) b\/(.+?)\n/);
+    const path = pathMatch?.[2] ?? block.match(/^\S+/)?.[0] ?? "unknown";
+    const hunkHeaders = [...full.matchAll(/^@@ .+? @@.*$/gm)].map((m) => m[0]);
+    map.set(path, {
+      hunkHeaders,
+      diffText: full.length > DIFF_CAP ? full.slice(0, DIFF_CAP) : full
+    });
+  }
+  return map;
+}
+function commitFiles(repoPath, sha) {
+  const stats = numstat(repoPath, sha);
+  const diff = git(repoPath, ["show", "--unified=0", "--format=", sha]);
+  const blocks = parseDiffBlocks(diff);
+  const paths = /* @__PURE__ */ new Set([...stats.keys(), ...blocks.keys()]);
+  const files = [];
+  for (const path of paths) {
+    const stat = stats.get(path) ?? { insertions: 0, deletions: 0 };
+    const block = blocks.get(path) ?? { hunkHeaders: [], diffText: "" };
+    files.push({
+      path,
+      insertions: stat.insertions,
+      deletions: stat.deletions,
+      hunkHeaders: block.hunkHeaders,
+      diffText: block.diffText,
+      diffTruncated: block.diffText.length >= DIFF_CAP
+    });
+  }
+  return files;
+}
+function parseGitLog(repoPath, repoId, known) {
+  const shas = listShas(repoPath).filter((sha) => !known?.has(sha));
+  const id = repoId ?? deriveRepoId(repoPath);
+  return shas.map((sha) => {
+    const meta = commitMeta(repoPath, sha);
+    const trailers = parseTrailers(repoPath, meta.message);
+    return {
+      sha: meta.sha,
+      repoId: id,
+      repoPath,
+      author: meta.author,
+      authorEmail: meta.authorEmail,
+      ts: meta.ts,
+      message: meta.message,
+      parents: meta.parents,
+      branch: commitBranch(repoPath, sha),
+      evrexSessionTrailer: trailerValue(trailers, EVREX_SESSION_TRAILER_KEY),
+      origin: originOf(trailers),
+      agentTrailers: agentTrailersOf(trailers),
+      statedInsights: statedInsightsOf(trailers),
+      files: commitFiles(repoPath, sha)
+    };
+  });
+}
+var DIFF_CAP, FIELD_SEP, EVREX_SESSION_TRAILER_KEY, EVREX_ORIGIN_TRAILER_KEY;
+var init_git_history = __esm({
+  "../../packages/ingest-core/src/git-history.ts"() {
+    "use strict";
+    init_types();
+    DIFF_CAP = 2e4;
+    FIELD_SEP = "";
+    EVREX_SESSION_TRAILER_KEY = "Evrex-Session";
+    EVREX_ORIGIN_TRAILER_KEY = "Evrex-Origin";
+  }
+});
 
-// ../../packages/ingest-core/src/claude-sessions.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+// ../../packages/ingest-core/src/incremental.ts
+import { statSync } from "node:fs";
+function planRead(path, cursor) {
+  let size;
+  let modifiedAt;
+  if (cursor && (cursor.parserVersion ?? 0) < PARSER_VERSION) {
+    cursor = void 0;
+  }
+  try {
+    const stat = statSync(path);
+    size = stat.size;
+    modifiedAt = stat.mtimeMs;
+  } catch {
+    return { path, from: 0, reason: "unchanged" };
+  }
+  if (!cursor) return { path, from: 0, reason: "new" };
+  if (size < cursor.size) return { path, from: 0, reason: "rewritten" };
+  if (size === cursor.size && modifiedAt <= cursor.modifiedAt) {
+    return { path, from: cursor.offset, reason: "unchanged" };
+  }
+  if (size === cursor.offset) return { path, from: cursor.offset, reason: "unchanged" };
+  return { path, from: cursor.offset, reason: "appended" };
+}
+function advanceCursor(path, consumedTo) {
+  let size = consumedTo;
+  let modifiedAt = Date.now();
+  try {
+    const stat = statSync(path);
+    size = stat.size;
+    modifiedAt = stat.mtimeMs;
+  } catch {
+  }
+  return { offset: consumedTo, size, modifiedAt, parserVersion: PARSER_VERSION };
+}
+function splitCompleteLines(chunk) {
+  const lastNewline = chunk.lastIndexOf("\n");
+  if (lastNewline === -1) return { lines: [], consumedBytes: 0 };
+  const complete = chunk.slice(0, lastNewline);
+  return {
+    lines: complete.split("\n").filter((l) => l.trim().length > 0),
+    consumedBytes: Buffer.byteLength(complete, "utf-8") + 1
+  };
+}
+function sessionSignature(session) {
+  const last = session.turns[session.turns.length - 1]?.ts ?? session.endedAt ?? "";
+  return `v${PARSER_VERSION}:${session.turnCount}:${last}`;
+}
+function changedSessions(sessions, known) {
+  const signatures = {};
+  const changed = [];
+  for (const session of sessions) {
+    const signature = sessionSignature(session);
+    signatures[session.id] = signature;
+    if (known[session.id] !== signature) changed.push(session);
+  }
+  return { changed, signatures };
+}
+var PARSER_VERSION;
+var init_incremental = __esm({
+  "../../packages/ingest-core/src/incremental.ts"() {
+    "use strict";
+    PARSER_VERSION = 4;
+  }
+});
+
+// ../../packages/ingest-core/src/derive-uuid.ts
+import { createHash } from "node:crypto";
+function deriveUuid(name) {
+  const h = createHash("sha1").update(name).digest("hex");
+  const variant = (parseInt(h.slice(16, 17) || "0", 16) & 3 | 8).toString(16);
+  const s = h.slice(0, 12) + // time-low + time-mid
+  "5" + // version 5 (name-based, SHA-1)
+  h.slice(13, 16) + variant + h.slice(17, 32);
+  return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20, 32)}`;
+}
+function deriveSlackSessionId(channel, threadTs) {
+  return deriveUuid(`evrex-slack-session ${channel} ${threadTs}`);
+}
+function deriveSlackTurnId(channel, messageTs) {
+  return deriveUuid(`evrex-slack-turn ${channel} ${messageTs}`);
+}
+var init_derive_uuid = __esm({
+  "../../packages/ingest-core/src/derive-uuid.ts"() {
+    "use strict";
+  }
+});
 
 // ../../packages/ingest-core/src/redact.ts
-var PATTERNS = [
-  { type: "private_key", regex: /-----BEGIN(?: [A-Z]+)? PRIVATE KEY-----[\s\S]*?-----END(?: [A-Z]+)? PRIVATE KEY-----/g },
-  { type: "aws_access_key", regex: /AKIA[0-9A-Z]{16}/g },
-  { type: "github_token", regex: /gh[pousr]_[A-Za-z0-9]{36,}/g },
-  { type: "slack_token", regex: /xox[baprs]-[A-Za-z0-9-]{10,}/g },
-  { type: "stripe_key", regex: /sk_(live|test)_[A-Za-z0-9]{24,}/g },
-  { type: "openai_key", regex: /sk-[A-Za-z0-9]{20,}/g },
-  { type: "anthropic_key", regex: /sk-ant-[A-Za-z0-9-_]{20,}/g },
-  { type: "jwt", regex: /eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g },
-  { type: "bearer_token", regex: /Bearer\s+[A-Za-z0-9\-_.]{20,}/g },
-  {
-    type: "env_secret",
-    regex: /\b([A-Z0-9_]*(?:_KEY|_SECRET|_TOKEN|_PASSWORD|PASSWD)[A-Z0-9_]*)\s*[:=]\s*["']?[^\s"'\n]{6,}["']?/g
-  }
-];
 function redactJsonValue(value) {
   let count = 0;
   const walk = (v) => {
@@ -190,7 +454,31 @@ function redactJsonValue(value) {
   };
   return { value: walk(value), count };
 }
-var PRIVATE_BLOCK = /<private>[\s\S]*?(?:<\/private>|$)/gi;
+function redactRawTranscript(content, format) {
+  let count = 0;
+  if (format === "jsonl") {
+    const out = content.split("\n").map((line) => {
+      if (!line.trim()) return line;
+      try {
+        const r = redactJsonValue(JSON.parse(line));
+        count += r.count;
+        return JSON.stringify(r.value);
+      } catch {
+        const r = redactSecrets(line);
+        count += r.count;
+        return r.text;
+      }
+    });
+    return { content: out.join("\n"), count };
+  }
+  try {
+    const r = redactJsonValue(JSON.parse(content));
+    return { content: JSON.stringify(r.value), count: r.count };
+  } catch {
+    const r = redactSecrets(content);
+    return { content: r.text, count: r.count };
+  }
+}
 function redactSecrets(input) {
   let text = input;
   let count = 0;
@@ -209,8 +497,74 @@ function redactSecrets(input) {
   }
   return { text, count };
 }
+var PATTERNS, PRIVATE_BLOCK;
+var init_redact = __esm({
+  "../../packages/ingest-core/src/redact.ts"() {
+    "use strict";
+    PATTERNS = [
+      { type: "private_key", regex: /-----BEGIN(?: [A-Z]+)? PRIVATE KEY-----[\s\S]*?-----END(?: [A-Z]+)? PRIVATE KEY-----/g },
+      { type: "aws_access_key", regex: /AKIA[0-9A-Z]{16}/g },
+      { type: "github_token", regex: /gh[pousr]_[A-Za-z0-9]{36,}/g },
+      { type: "slack_token", regex: /xox[baprs]-[A-Za-z0-9-]{10,}/g },
+      { type: "stripe_key", regex: /sk_(live|test)_[A-Za-z0-9]{24,}/g },
+      { type: "openai_key", regex: /sk-[A-Za-z0-9]{20,}/g },
+      { type: "anthropic_key", regex: /sk-ant-[A-Za-z0-9-_]{20,}/g },
+      { type: "jwt", regex: /eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g },
+      { type: "bearer_token", regex: /Bearer\s+[A-Za-z0-9\-_.]{20,}/g },
+      {
+        type: "env_secret",
+        regex: /\b([A-Z0-9_]*(?:_KEY|_SECRET|_TOKEN|_PASSWORD|PASSWD)[A-Z0-9_]*)\s*[:=]\s*["']?[^\s"'\n]{6,}["']?/g
+      }
+    ];
+    PRIVATE_BLOCK = /<private>[\s\S]*?(?:<\/private>|$)/gi;
+  }
+});
 
 // ../../packages/ingest-core/src/subject-linking.ts
+function matchCommitToSession(commit, sessions) {
+  const subject = commit.subject.trim();
+  if (subject.length === 0) {
+    return { sha: commit.sha, sessionId: null, reason: "absent" };
+  }
+  const ran = sessions.filter((s) => s.committedSubjects.includes(subject));
+  if (ran.length === 0) {
+    return { sha: commit.sha, sessionId: null, reason: "absent" };
+  }
+  if (ran.length === 1) {
+    return {
+      sha: commit.sha,
+      sessionId: ran[0].sessionId,
+      evidence: "ran-the-commit",
+      confidence: INFERRED_CONFIDENCE
+    };
+  }
+  const oneLineage = ran.every((s) => s.startedAt === ran[0].startedAt);
+  if (!oneLineage) {
+    return { sha: commit.sha, sessionId: null, reason: "ambiguous" };
+  }
+  const original = [...ran].sort((a, b) => a.endedAt - b.endedAt)[0];
+  return {
+    sha: commit.sha,
+    sessionId: original.sessionId,
+    evidence: "ran-the-commit-then-lineage",
+    confidence: INFERRED_CONFIDENCE
+  };
+}
+function proposeLinks(commits, sessions) {
+  const out = [];
+  for (const commit of commits) {
+    const match = matchCommitToSession(commit, sessions);
+    if (match.sessionId !== null) {
+      out.push({
+        sha: match.sha,
+        sessionId: match.sessionId,
+        confidence: match.confidence,
+        evidence: match.evidence
+      });
+    }
+  }
+  return out;
+}
 function committedSubjects(command) {
   const out = [];
   const invocation = /\bgit\s+(?:-C\s+\S+\s+)?commit\b/g;
@@ -230,30 +584,18 @@ function committedSubjects(command) {
   }
   return out;
 }
-
-// ../../packages/ingest-core/src/types.ts
-var CONVERSATION_KINDS = [
-  "claude-code",
-  "cursor",
-  "codex",
-  "gemini",
-  "slack"
-];
-var REFERENCE_KINDS = ["linear", "jira", "confluence"];
-var SOURCE_KINDS = [
-  ...CONVERSATION_KINDS,
-  ...REFERENCE_KINDS
-];
-var EMPTY_USAGE = {
-  inputTokens: null,
-  outputTokens: null,
-  cacheReadTokens: null,
-  cacheWriteTokens: null,
-  model: null
-};
+var INFERRED_CONFIDENCE;
+var init_subject_linking = __esm({
+  "../../packages/ingest-core/src/subject-linking.ts"() {
+    "use strict";
+    INFERRED_CONFIDENCE = 0.9;
+  }
+});
 
 // ../../packages/ingest-core/src/claude-sessions.ts
-var MIN_MEANINGFUL_LINE_LENGTH = 6;
+import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, statSync as statSync2 } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 function meaningfulLines(lines) {
   return lines.map((l) => l.trim()).filter((l) => l.length >= MIN_MEANINGFUL_LINE_LENGTH);
 }
@@ -280,9 +622,56 @@ function extractEditedLines(toolUseResult) {
   if (meaningfulAdded.length === 0 && meaningfulRemoved.length === 0) return null;
   return { path: r.filePath, added: meaningfulAdded, removed: meaningfulRemoved };
 }
-var MAX_TURN_TEXT_LENGTH = 4e3;
-var FILE_PATH_TOOLS = /* @__PURE__ */ new Set(["Read", "Edit", "Write", "NotebookEdit"]);
-var PATH_TOKEN_RE = /(?:[.~]?\/)?(?:[\w-]+\/)+[\w.-]+/g;
+function slugifyCwd(repoPath) {
+  return repoPath.replace(/[^A-Za-z0-9]/g, "-");
+}
+function claudeProjectsDir() {
+  return join(homedir(), ".claude", "projects");
+}
+function xcodeAssistantProjectsDir() {
+  return join(
+    homedir(),
+    "Library",
+    "Developer",
+    "Xcode",
+    "CodingAssistant",
+    "ClaudeAgentConfig",
+    "projects"
+  );
+}
+function findSessionFiles(repoPath) {
+  const roots = [
+    { dir: claudeProjectsDir(), agentKind: "claude-code" },
+    { dir: xcodeAssistantProjectsDir(), agentKind: "claude-xcode" }
+  ];
+  const out = [];
+  for (const { dir, agentKind } of roots) {
+    const slug = join(dir, slugifyCwd(repoPath));
+    if (!existsSync(slug)) continue;
+    for (const name of readdirSync(slug)) {
+      if (name.endsWith(".jsonl")) out.push({ file: join(slug, name), agentKind });
+      const subagents = join(slug, name, "subagents");
+      if (!name.endsWith(".jsonl") && existsSync(subagents)) {
+        for (const child of readdirSync(subagents)) {
+          if (child.endsWith(".jsonl")) out.push({ file: join(subagents, child), agentKind });
+        }
+      }
+    }
+  }
+  return out;
+}
+function editFromXcodeInput(input) {
+  const filePath = input.filePath;
+  if (typeof filePath !== "string" || !filePath) return null;
+  const oldLines = typeof input.oldString === "string" ? input.oldString.split("\n") : [];
+  const newLines = typeof input.newString === "string" ? input.newString.split("\n") : [];
+  const oldSet = new Set(oldLines);
+  const newSet = new Set(newLines);
+  const added = meaningfulLines(newLines.filter((l) => !oldSet.has(l)));
+  const removed = meaningfulLines(oldLines.filter((l) => !newSet.has(l)));
+  if (added.length === 0 && removed.length === 0) return null;
+  return { path: filePath, added, removed };
+}
 function extractPathsFromText(text) {
   const matches = text.match(PATH_TOKEN_RE) ?? [];
   return [...new Set(matches)].filter((p) => p.length > 3 && p.length < 300);
@@ -297,6 +686,7 @@ function blockText(content) {
 function extractFromAssistantContent(content) {
   const textParts = [];
   const filesTouched = [];
+  const editedLines = [];
   for (const block of content) {
     if (block.type === "text" && block.text) {
       textParts.push(block.text);
@@ -306,7 +696,15 @@ function extractFromAssistantContent(content) {
     } else if (block.type === "tool_use") {
       const name = block.name ?? "tool";
       const input = block.input ?? {};
-      if (FILE_PATH_TOOLS.has(name) && typeof input.file_path === "string") {
+      if (XCODE_EDIT_TOOL.test(name) && typeof input.filePath === "string") {
+        textParts.push(`[tool_call: ${name}] ${input.filePath}`);
+        filesTouched.push({ path: input.filePath, source: "tool_path", tool: name });
+        const edit = editFromXcodeInput(input);
+        if (edit) editedLines.push(edit);
+      } else if (XCODE_PATH_TOOLS.test(name) && typeof input.filePath === "string") {
+        textParts.push(`[tool_call: ${name}] ${input.filePath}`);
+        filesTouched.push({ path: input.filePath, source: "tool_path", tool: name });
+      } else if (FILE_PATH_TOOLS.has(name) && typeof input.file_path === "string") {
         textParts.push(`[tool_call: ${name}] ${input.file_path}`);
         filesTouched.push({ path: input.file_path, source: "tool_path", tool: name });
       } else if (name === "Bash" && typeof input.command === "string") {
@@ -320,9 +718,8 @@ function extractFromAssistantContent(content) {
       }
     }
   }
-  return { text: textParts.join("\n"), filesTouched };
+  return { text: textParts.join("\n"), filesTouched, editedLines };
 }
-var SYNTHETIC_CONTENT_RE = /^\s*(<task-notification>|<system-reminder>|\[SYSTEM NOTIFICATION)/;
 function extractFromUserContent(content) {
   if (typeof content === "string") {
     return {
@@ -334,9 +731,11 @@ function extractFromUserContent(content) {
   if (Array.isArray(content)) {
     const toolParts = [];
     const textParts = [];
+    let isToolError = false;
     for (const block of content) {
       if (block.type === "tool_result") {
         toolParts.push(blockText(block.content));
+        if (block.is_error === true) isToolError = true;
       } else if (block.type === "text" && typeof block.text === "string") {
         textParts.push(block.text);
       }
@@ -345,7 +744,8 @@ function extractFromUserContent(content) {
       return {
         text: toolParts.join("\n"),
         filesTouched: [],
-        isSyntheticInput: true
+        isSyntheticInput: true,
+        isToolError
       };
     }
     const text = textParts.join("\n");
@@ -381,8 +781,35 @@ function usageOnce(record, billed) {
     model: typeof message?.model === "string" ? message.model : null
   };
 }
-function parseSessionFile(filePath, repoPath, repoId = deriveRepoId(repoPath)) {
-  const raw = readFileSync(filePath, "utf-8");
+function readTranscript(filePath) {
+  const size = statSync2(filePath).size;
+  if (size <= MAX_TRANSCRIPT_BYTES) {
+    return { text: readFileSync(filePath, "utf-8"), capped: false };
+  }
+  const fd = openSync(filePath, "r");
+  try {
+    const buf = Buffer.alloc(MAX_TRANSCRIPT_BYTES);
+    readSync(fd, buf, 0, MAX_TRANSCRIPT_BYTES, size - MAX_TRANSCRIPT_BYTES);
+    const text = buf.toString("utf-8");
+    return { text: text.slice(text.indexOf("\n") + 1), capped: true };
+  } finally {
+    closeSync(fd);
+  }
+}
+function readSubagentMeta(transcriptPath) {
+  const metaPath = transcriptPath.replace(/\.jsonl$/, ".meta.json");
+  try {
+    const raw = JSON.parse(readFileSync(metaPath, "utf-8"));
+    return {
+      agentType: typeof raw.agentType === "string" ? raw.agentType : null,
+      description: typeof raw.description === "string" ? raw.description : null
+    };
+  } catch {
+    return null;
+  }
+}
+function parseSessionFile(filePath, repoPath, repoId = deriveRepoId(repoPath), agentKind = "claude-code") {
+  const { text: raw, capped } = readTranscript(filePath);
   const lines = raw.split("\n").filter((l) => l.trim().length > 0);
   const turns = [];
   const billedMessages = /* @__PURE__ */ new Set();
@@ -390,6 +817,9 @@ function parseSessionFile(filePath, repoPath, repoId = deriveRepoId(repoPath)) {
   const cwd = repoPath;
   let aiTitle = null;
   let totalRedactions = 0;
+  let branch = null;
+  let agentId = null;
+  const seenIds = /* @__PURE__ */ new Set();
   for (const line of lines) {
     let record;
     try {
@@ -405,23 +835,30 @@ function parseSessionFile(filePath, repoPath, repoId = deriveRepoId(repoPath)) {
     const id = record.uuid;
     const ts = record.timestamp;
     if (!id || !ts) continue;
+    if (seenIds.has(id)) continue;
+    seenIds.add(id);
     sessionId ??= record.sessionId ?? record.session_id ?? null;
+    if (typeof record.gitBranch === "string" && record.gitBranch) branch = record.gitBranch;
+    if (typeof record.agentId === "string" && record.agentId) agentId ??= record.agentId;
     let text = "";
     let filesTouched = [];
     let editedLines = [];
     let isSyntheticInput = false;
+    let isToolError = false;
     if (record.type === "assistant") {
       const content = record.message?.content;
       if (Array.isArray(content)) {
         const extracted = extractFromAssistantContent(content);
         text = extracted.text;
         filesTouched = extracted.filesTouched;
+        editedLines = extracted.editedLines;
       }
     } else {
       const extracted = extractFromUserContent(record.message?.content);
       text = extracted.text;
       filesTouched = extracted.filesTouched;
       isSyntheticInput = extracted.isSyntheticInput;
+      isToolError = extracted.isToolError ?? false;
       const edited = extractEditedLines(record.toolUseResult);
       if (edited) editedLines = [edited];
     }
@@ -439,12 +876,21 @@ function parseSessionFile(filePath, repoPath, repoId = deriveRepoId(repoPath)) {
       isSidechain: Boolean(record.isSidechain),
       redacted: redacted.count > 0,
       isSyntheticInput,
+      isToolError,
       usage: usageOnce(record, billedMessages)
     });
   }
   if (!sessionId || turns.length === 0) return null;
+  const parentSessionId = agentId ? sessionId : null;
+  if (agentId) {
+    sessionId = deriveUuid(`evrex-subagent\0${parentSessionId}\0${agentId}`);
+    for (const t of turns) t.sessionId = sessionId;
+  }
+  const meta = agentId ? readSubagentMeta(filePath) : null;
+  const subagent = agentId ? { agentId, agentType: meta?.agentType ?? null, description: meta?.description ?? null } : null;
+  if (agentId && !aiTitle && meta?.description) aiTitle = meta.description;
   const sortedTs = turns.map((t) => t.ts).sort();
-  const rawContent = lines.map((line) => {
+  const rawContent = capped ? "" : lines.map((line) => {
     try {
       return JSON.stringify(redactJsonValue(JSON.parse(line)).value);
     } catch {
@@ -456,7 +902,7 @@ function parseSessionFile(filePath, repoPath, repoId = deriveRepoId(repoPath)) {
   }
   return {
     id: sessionId,
-    agentKind: "claude-code",
+    agentKind,
     repoId,
     cwd,
     startedAt: sortedTs[0] ?? null,
@@ -468,6 +914,9 @@ function parseSessionFile(filePath, repoPath, repoId = deriveRepoId(repoPath)) {
     sourceFile: filePath,
     redactionCount: totalRedactions,
     committedSubjects: collectCommittedSubjects(lines),
+    branch,
+    parentSessionId,
+    subagent,
     rawContent,
     rawFormat: "jsonl",
     turns
@@ -494,45 +943,911 @@ function collectCommittedSubjects(lines) {
   }
   return [...subjects];
 }
-
-// ../../packages/ingest-core/src/derive-uuid.ts
-import { createHash } from "node:crypto";
-function deriveUuid(name) {
-  const h = createHash("sha1").update(name).digest("hex");
-  const variant = (parseInt(h.slice(16, 17) || "0", 16) & 3 | 8).toString(16);
-  const s = h.slice(0, 12) + // time-low + time-mid
-  "5" + // version 5 (name-based, SHA-1)
-  h.slice(13, 16) + variant + h.slice(17, 32);
-  return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20, 32)}`;
+function parseAllSessions(repoPath, repoId, cursors = {}) {
+  const id = repoId ?? deriveRepoId(repoPath);
+  const next = { ...cursors };
+  const sessions = [];
+  let skipped = 0;
+  for (const { file, agentKind } of findSessionFiles(repoPath)) {
+    const plan = planRead(file, cursors[file]);
+    if (plan.reason === "unchanged") {
+      skipped++;
+      continue;
+    }
+    const parsed = parseSessionFile(file, repoPath, id, agentKind);
+    if (!parsed) continue;
+    sessions.push(parsed);
+    next[file] = advanceCursor(file, statSync2(file).size);
+  }
+  return { sessions, cursors: next, skipped };
 }
+var MIN_MEANINGFUL_LINE_LENGTH, MAX_TURN_TEXT_LENGTH, FILE_PATH_TOOLS, XCODE_EDIT_TOOL, XCODE_PATH_TOOLS, PATH_TOKEN_RE, SYNTHETIC_CONTENT_RE, MAX_TRANSCRIPT_BYTES;
+var init_claude_sessions = __esm({
+  "../../packages/ingest-core/src/claude-sessions.ts"() {
+    "use strict";
+    init_incremental();
+    init_git_history();
+    init_derive_uuid();
+    init_redact();
+    init_subject_linking();
+    init_types();
+    MIN_MEANINGFUL_LINE_LENGTH = 6;
+    MAX_TURN_TEXT_LENGTH = 4e3;
+    FILE_PATH_TOOLS = /* @__PURE__ */ new Set(["Read", "Edit", "Write", "NotebookEdit"]);
+    XCODE_EDIT_TOOL = /XcodeUpdate$/;
+    XCODE_PATH_TOOLS = /Xcode(Read|Grep|Glob|RefreshCodeIssuesInFile)$/;
+    PATH_TOKEN_RE = /(?:[.~]?\/)?(?:[\w-]+\/)+[\w.-]+/g;
+    SYNTHETIC_CONTENT_RE = /^\s*(<task-notification>|<system-reminder>|\[SYSTEM NOTIFICATION)/;
+    MAX_TRANSCRIPT_BYTES = 256 * 1024 * 1024;
+  }
+});
 
-// ../../packages/ingest-core/src/codex-sessions.ts
-import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-function deriveUuid2(name) {
-  const h = createHash2("sha1").update(name).digest("hex");
-  const variant = (parseInt(h.slice(16, 17) || "0", 16) & 3 | 8).toString(16);
-  const s = h.slice(0, 12) + "5" + h.slice(13, 16) + variant + h.slice(17, 32);
-  return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20, 32)}`;
+// ../../packages/ingest-core/src/cursor-sessions.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2, sep } from "node:path";
+function extractPathsFromText2(text) {
+  const matches = text.match(PATH_TOKEN_RE2) ?? [];
+  return [...new Set(matches)].filter((p) => p.length > 3 && p.length < 300);
 }
-function deriveCodexTurnId(sessionId, ordinal) {
-  return deriveUuid2(`evrex-codex-turn\0${sessionId}\0${ordinal}`);
+function cursorStateDbPath() {
+  const home = homedir2();
+  if (process.platform === "darwin") {
+    return join2(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? join2(home, "AppData", "Roaming");
+    return join2(appData, "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+  return join2(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb");
 }
-function parseLines(raw) {
-  const out = [];
-  for (const line of raw.split("\n")) {
-    if (!line.trim()) continue;
+function sqliteJson(dbPath, sql) {
+  try {
+    const out = execFileSync2("sqlite3", ["-readonly", "-json", dbPath, sql], {
+      maxBuffer: 1024 * 1024 * 256,
+      timeout: 6e4
+    }).toString("utf-8").trim();
+    if (!out) return [];
+    return JSON.parse(out);
+  } catch {
+    return [];
+  }
+}
+function sqlLiteral(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function deriveCursorSessionId(composerId, repoPath) {
+  return deriveUuid(`evrex-cursor-session\0${composerId}\0${repoPath}`);
+}
+function deriveCursorTurnId(bubbleId, repoPath) {
+  return deriveUuid(`evrex-cursor-turn\0${bubbleId}\0${repoPath}`);
+}
+function loadComposers(dbPath) {
+  return sqliteJson(
+    dbPath,
+    `SELECT
+       json_extract(value,'$.composerId')                   AS composerId,
+       json_extract(value,'$.name')                         AS name,
+       json_extract(value,'$.createdAt')                    AS createdAt,
+       json_extract(value,'$.lastUpdatedAt')                AS lastUpdatedAt,
+       json_extract(value,'$.workspaceIdentifier.uri.path') AS workspacePath,
+       json_extract(value,'$.fullConversationHeadersOnly')  AS headers
+     FROM cursorDiskKV
+     WHERE key GLOB 'composerData:*'`
+  );
+}
+function composerIdsReferencingRepo(dbPath, repoPath) {
+  const needle = sqlLiteral(`%${repoPath}%`);
+  const rows = sqliteJson(
+    dbPath,
+    `SELECT DISTINCT substr(key, 10, 36) AS composerId
+     FROM cursorDiskKV
+     WHERE key GLOB 'bubbleId:*' AND value LIKE ${needle}`
+  );
+  return rows.map((r) => r.composerId).filter((id) => !!id);
+}
+function bubbleIdsReferencingRepo(dbPath, composerId, repoPath) {
+  const prefix = sqlLiteral(`bubbleId:${composerId}:%`);
+  const needle = sqlLiteral(`%${repoPath}%`);
+  const rows = sqliteJson(
+    dbPath,
+    `SELECT substr(key, ${10 + composerId.length + 1}) AS bubbleId
+     FROM cursorDiskKV
+     WHERE key LIKE ${prefix} AND value LIKE ${needle}`
+  );
+  return new Set(rows.map((r) => r.bubbleId).filter((id) => !!id));
+}
+function loadBubbles(dbPath, composerId) {
+  const prefix = sqlLiteral(`bubbleId:${composerId}:%`);
+  const rows = sqliteJson(
+    dbPath,
+    `SELECT
+       substr(key, ${10 + composerId.length + 1}) AS bubbleId,
+       json_extract(value,'$.type')                 AS type,
+       json_extract(value,'$.text')                 AS text,
+       json_extract(value,'$.thinking.text')        AS thinking,
+       json_extract(value,'$.toolFormerData.name')  AS toolName,
+       json_extract(value,'$.toolFormerData.rawArgs') AS rawArgs,
+       json_extract(value,'$.createdAt')            AS createdAt
+     FROM cursorDiskKV
+     WHERE key LIKE ${prefix}`
+  );
+  const map = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (r.bubbleId) map.set(r.bubbleId, r);
+  }
+  return map;
+}
+function loadRawRecords(dbPath, composerId, bubbleIds) {
+  const keys = [
+    `composerData:${composerId}`,
+    ...bubbleIds.map((b) => `bubbleId:${composerId}:${b}`)
+  ];
+  const inList = keys.map((k) => sqlLiteral(k)).join(", ");
+  const rows = sqliteJson(
+    dbPath,
+    `SELECT key, value FROM cursorDiskKV WHERE key IN (${inList})`
+  );
+  const records = {};
+  for (const { key, value } of rows) {
+    if (!key) continue;
     try {
-      out.push(JSON.parse(line));
+      records[key] = value ? JSON.parse(value) : null;
     } catch {
-      continue;
+      records[key] = value;
     }
   }
-  return out;
+  return records;
 }
-function payloadType(line) {
-  const t = line.payload?.type;
-  return typeof t === "string" ? t : void 0;
+function parseHeaders(headers2) {
+  if (!headers2) return [];
+  try {
+    const parsed = JSON.parse(headers2);
+    return Array.isArray(parsed) ? parsed.filter((h) => h && h.bubbleId) : [];
+  } catch {
+    return [];
+  }
+}
+function filesFromTool(toolName, rawArgs) {
+  const files = [];
+  let label = `[tool_call: ${toolName}]`;
+  if (!rawArgs) return { label, files };
+  let args = {};
+  try {
+    args = JSON.parse(rawArgs);
+  } catch {
+    return { label, files };
+  }
+  const filePath = typeof args.target_file === "string" && args.target_file || typeof args.path === "string" && args.path || typeof args.relative_workspace_path === "string" && args.relative_workspace_path || null;
+  const command = typeof args.command === "string" ? args.command : null;
+  if (filePath) {
+    label = `[tool_call: ${toolName}] ${filePath}`;
+    files.push({ path: filePath, source: "tool_path", tool: toolName });
+  } else if (command) {
+    label = `[tool_call: ${toolName}] ${command}`;
+    for (const p of extractPathsFromText2(command)) {
+      files.push({ path: p, source: "tool_bash", tool: toolName });
+    }
+  }
+  return { label, files };
+}
+function toIso(value, fallbackMs) {
+  if (typeof value === "string" && value) {
+    const t = Date.parse(value);
+    if (!Number.isNaN(t)) return new Date(t).toISOString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return new Date(value).toISOString();
+  }
+  return new Date(fallbackMs).toISOString();
+}
+function parseCursorComposer(dbPath, composer, repoPath, options = { scoped: false }, repoId = deriveRepoId(repoPath)) {
+  const composerId = composer.composerId;
+  if (!composerId) return null;
+  const headers2 = parseHeaders(composer.headers);
+  if (headers2.length === 0) return null;
+  const bubbles = loadBubbles(dbPath, composerId);
+  const composerCreatedMs = typeof composer.createdAt === "number" ? composer.createdAt : Date.now();
+  const referencing = options.scoped ? bubbleIdsReferencingRepo(dbPath, composerId, repoPath) : null;
+  const built = [];
+  for (const header of headers2) {
+    const bubble = bubbles.get(header.bubbleId);
+    if (!bubble) continue;
+    const role = header.type === 1 ? "user" : "assistant";
+    const textParts = [];
+    const filesTouched = [];
+    if (bubble.text && bubble.text.trim()) {
+      textParts.push(bubble.text);
+      for (const p of extractPathsFromText2(bubble.text)) {
+        filesTouched.push({ path: p, source: "prose" });
+      }
+    }
+    if (role === "assistant" && bubble.thinking && bubble.thinking.trim()) {
+      textParts.push(bubble.thinking);
+    }
+    if (bubble.toolName) {
+      const { label, files } = filesFromTool(bubble.toolName, bubble.rawArgs);
+      textParts.push(label);
+      filesTouched.push(...files);
+    }
+    const text = textParts.join("\n");
+    if (!text.trim() && filesTouched.length === 0) continue;
+    const redacted = redactSecrets(text);
+    built.push({
+      bubbleId: header.bubbleId,
+      role,
+      referencesRepo: referencing ? referencing.has(header.bubbleId) : true,
+      redactionCount: redacted.count,
+      turn: {
+        id: header.bubbleId,
+        // rewritten to the per-repo derived id below
+        sessionId: composerId,
+        // rewritten to the per-repo derived id below
+        role,
+        ts: toIso(bubble.createdAt, composerCreatedMs),
+        text: redacted.text.slice(0, MAX_TURN_TEXT_LENGTH2),
+        filesTouched,
+        // Cursor's bubble format doesn't expose a structuredPatch-equivalent
+        // the way Claude Code's toolUseResult does — content-overlap scoring
+        // (see scoreContentOverlap in the linker) simply has no signal here
+        // yet, same tier as any other not-yet-supported evidence source.
+        editedLines: [],
+        // Cursor has no parent-pointer chain; header order is authoritative, so
+        // parentUuid is left null (the backend/linker never require it).
+        parentUuid: null,
+        isSidechain: false,
+        redacted: redacted.count > 0,
+        // Cursor's "user" bubbles (header.type === 1, see `role` above) are a
+        // structural field distinct from tool output — not the Claude Code
+        // wire-format ambiguity where a tool result also arrives as a
+        // `role: "user"` record. No synthetic-input misattribution risk here.
+        isSyntheticInput: false,
+        isToolError: false,
+        // Neither source reports what a turn cost, so it is unknown rather than free.
+        usage: { ...EMPTY_USAGE }
+      }
+    });
+  }
+  let kept;
+  if (referencing) {
+    const keep2 = /* @__PURE__ */ new Set();
+    for (let i = 0; i < built.length; i++) {
+      const cur = built[i];
+      if (!cur || !cur.referencesRepo) continue;
+      keep2.add(i);
+      const prev = built[i - 1];
+      if (prev && prev.role === "user") keep2.add(i - 1);
+    }
+    kept = built.filter((_, i) => keep2.has(i));
+  } else {
+    kept = built;
+  }
+  if (kept.length === 0) return null;
+  const sessionId = deriveCursorSessionId(composerId, repoPath);
+  const turns = kept.map((b) => ({
+    ...b.turn,
+    id: deriveCursorTurnId(b.bubbleId, repoPath),
+    sessionId
+  }));
+  const totalRedactions = kept.reduce((sum, b) => sum + b.redactionCount, 0);
+  const sortedTs = turns.map((t) => t.ts).sort();
+  if (totalRedactions > 0) {
+    console.log(`[ingest-core] redacted ${totalRedactions} potential secret(s) in cursor session ${composerId}`);
+  }
+  const rawRecords = loadRawRecords(dbPath, composerId, kept.map((b) => b.bubbleId));
+  const rawContent = JSON.stringify(
+    redactJsonValue({ format: "cursor-composer", composerId, records: rawRecords }).value
+  );
+  return {
+    id: sessionId,
+    agentKind: "cursor",
+    repoId,
+    cwd: repoPath,
+    startedAt: sortedTs[0] ?? null,
+    endedAt: sortedTs[sortedTs.length - 1] ?? null,
+    turnCount: turns.length,
+    aiTitle: composer.name && composer.name.trim() ? composer.name : null,
+    author: null,
+    // filled in by the caller — see collectRepoData
+    // Includes repoPath so a shared composer's per-repo copies have distinct,
+    // traceable source refs (the raw composerId alone is no longer unique).
+    sourceFile: `${dbPath}#${composerId}#${repoPath}`,
+    redactionCount: totalRedactions,
+    // Read back off the turns rather than the raw records: unlike Claude Code,
+    // a Cursor tool call's label keeps the command itself, so the invocation is
+    // still there to read.
+    committedSubjects: [
+      ...new Set(turns.flatMap((t) => committedSubjects(t.text)))
+    ],
+    rawContent,
+    branch: null,
+    parentSessionId: null,
+    subagent: null,
+    rawFormat: "json",
+    turns
+  };
+}
+function workspaceMatchesRepo(workspacePath, repoPath) {
+  if (!workspacePath) return false;
+  return workspacePath === repoPath || workspacePath.startsWith(`${repoPath}${sep}`);
+}
+function parseCursorConversation(composerId, repoPath, repoId, dbPath = cursorStateDbPath()) {
+  if (!existsSync2(dbPath)) return null;
+  const composer = loadComposers(dbPath).find((c) => c.composerId === composerId);
+  if (!composer) return null;
+  return parseCursorComposer(dbPath, composer, repoPath, { scoped: false }, repoId);
+}
+function parseAllCursorSessions(repoPath, repoId) {
+  const dbPath = cursorStateDbPath();
+  if (!existsSync2(dbPath)) return [];
+  const composers = loadComposers(dbPath);
+  if (composers.length === 0) return [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const c of composers) {
+    if (c.composerId) byId.set(c.composerId, c);
+  }
+  const workspaceDedicated = /* @__PURE__ */ new Set();
+  for (const c of composers) {
+    if (c.composerId && workspaceMatchesRepo(c.workspacePath, repoPath)) {
+      workspaceDedicated.add(c.composerId);
+    }
+  }
+  const attributed = new Set(workspaceDedicated);
+  for (const id of composerIdsReferencingRepo(dbPath, repoPath)) {
+    attributed.add(id);
+  }
+  const resolvedRepoId = repoId ?? deriveRepoId(repoPath);
+  const sessions = [];
+  for (const id of attributed) {
+    const composer = byId.get(id);
+    if (!composer) continue;
+    const scoped = !workspaceDedicated.has(id);
+    const parsed = parseCursorComposer(dbPath, composer, repoPath, { scoped }, resolvedRepoId);
+    if (parsed) sessions.push(parsed);
+  }
+  return sessions;
+}
+var MAX_TURN_TEXT_LENGTH2, PATH_TOKEN_RE2;
+var init_cursor_sessions = __esm({
+  "../../packages/ingest-core/src/cursor-sessions.ts"() {
+    "use strict";
+    init_git_history();
+    init_redact();
+    init_derive_uuid();
+    init_subject_linking();
+    init_types();
+    MAX_TURN_TEXT_LENGTH2 = 4e3;
+    PATH_TOKEN_RE2 = /(?:[.~]?\/)?(?:[\w-]+\/)+[\w.-]+/g;
+  }
+});
+
+// ../../packages/ingest-core/src/opencode-sessions.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+function opencodeDbPath(env = process.env, home = homedir3()) {
+  const data = env.XDG_DATA_HOME || join3(home, ".local", "share");
+  return join3(data, "opencode", "opencode.db");
+}
+function q(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function parseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function deriveOpenCodeSessionId(sessionId) {
+  return deriveUuid(`evrex-opencode\0${sessionId}`);
+}
+function deriveTurnId(partOrMessageId, suffix = "") {
+  return deriveUuid(`evrex-opencode-turn\0${partOrMessageId}${suffix}`);
+}
+function filesFromTool2(tool, input) {
+  const out = [];
+  for (const key of ["filePath", "path", "file"]) {
+    const v = input[key];
+    if (typeof v === "string" && v.length > 0) out.push({ path: v, source: "tool_path", tool });
+  }
+  const command = input.command;
+  if (tool === "bash" && typeof command === "string") {
+    for (const p of extractPathsFromText(command)) out.push({ path: p, source: "tool_bash", tool });
+  }
+  return out;
+}
+function usageOf(message) {
+  const t = message.tokens;
+  if (!t) return { ...EMPTY_USAGE, model: message.modelID ?? null };
+  return {
+    inputTokens: t.input ?? null,
+    outputTokens: t.output ?? null,
+    cacheReadTokens: t.cache?.read ?? null,
+    cacheWriteTokens: t.cache?.write ?? null,
+    model: message.modelID ?? null
+  };
+}
+function buildOpenCodeSession(session, messages, parts, repoId, sourceFile) {
+  const id = deriveOpenCodeSessionId(session.id);
+  const partsByMessage = /* @__PURE__ */ new Map();
+  for (const p of parts) {
+    const list = partsByMessage.get(p.message_id) ?? [];
+    list.push(p);
+    partsByMessage.set(p.message_id, list);
+  }
+  const turns = [];
+  let redactionCount = 0;
+  let previous = null;
+  const subjects = [];
+  const push = (turn) => {
+    const redacted = redactSecrets(turn.text);
+    redactionCount += redacted.count;
+    turns.push({
+      ...turn,
+      text: redacted.text,
+      sessionId: id,
+      parentUuid: previous,
+      isSidechain: false,
+      redacted: redacted.count > 0,
+      editedLines: []
+    });
+    previous = turn.id;
+  };
+  const at = (ms) => new Date(ms).toISOString();
+  for (const m of [...messages].sort((a, b) => a.time_created - b.time_created)) {
+    const data = parseJson(m.data);
+    if (!data?.role) continue;
+    const mparts = (partsByMessage.get(m.id) ?? []).sort((a, b) => a.time_created - b.time_created);
+    if (data.role === "user") {
+      const text = mparts.map((p) => parseJson(p.data)).filter((p) => !!p && p.type === "text" && typeof p.text === "string").map((p) => p.text).join("\n").trim();
+      if (!text) continue;
+      push({
+        id: deriveTurnId(m.id),
+        role: "user",
+        ts: at(data.time?.created ?? m.time_created),
+        text,
+        filesTouched: extractPathsFromText(text).map((path) => ({ path, source: "prose" })),
+        usage: EMPTY_USAGE,
+        isSyntheticInput: false,
+        isToolError: false
+      });
+      continue;
+    }
+    const usage = usageOf(data);
+    let usageGiven = false;
+    const take = () => {
+      if (usageGiven) return EMPTY_USAGE;
+      usageGiven = true;
+      return usage;
+    };
+    for (const p of mparts) {
+      const part = parseJson(p.data);
+      if (!part) continue;
+      if (part.type === "text" && typeof part.text === "string" && part.text.trim()) {
+        push({
+          id: deriveTurnId(p.id),
+          role: "assistant",
+          ts: at(p.time_created),
+          text: part.text.trim(),
+          filesTouched: [],
+          usage: take(),
+          isSyntheticInput: false,
+          isToolError: false
+        });
+      } else if (part.type === "tool" && typeof part.tool === "string") {
+        const input = part.state?.input ?? {};
+        const args = JSON.stringify(input);
+        const files = filesFromTool2(part.tool, input);
+        if (part.tool === "bash" && typeof input.command === "string") {
+          subjects.push(...committedSubjects(input.command));
+        }
+        push({
+          id: deriveTurnId(p.id, ":call"),
+          role: "assistant",
+          ts: at(p.time_created),
+          text: `[tool: ${part.tool}] ${args.length > 600 ? `${args.slice(0, 600)}\u2026` : args}`,
+          filesTouched: files,
+          usage: take(),
+          isSyntheticInput: false,
+          isToolError: false
+        });
+        const failed = part.state?.status === "error";
+        const output = failed ? part.state?.error ?? part.state?.output ?? "" : part.state?.output ?? "";
+        push({
+          id: deriveTurnId(p.id, ":result"),
+          role: "user",
+          ts: at(p.time_created),
+          text: output.length > MAX_OUTPUT_CHARS ? `${output.slice(0, MAX_OUTPUT_CHARS)}\u2026` : output,
+          filesTouched: [],
+          usage: EMPTY_USAGE,
+          isSyntheticInput: true,
+          isToolError: failed
+        });
+      }
+    }
+  }
+  if (turns.length === 0) return null;
+  return {
+    id,
+    agentKind: "opencode",
+    repoId,
+    cwd: session.directory,
+    startedAt: new Date(session.time_created).toISOString(),
+    endedAt: new Date(session.time_updated).toISOString(),
+    turnCount: turns.length,
+    aiTitle: session.title || null,
+    author: null,
+    sourceFile,
+    redactionCount,
+    committedSubjects: [...new Set(subjects)],
+    parentSessionId: session.parent_id ? deriveOpenCodeSessionId(session.parent_id) : null,
+    subagent: session.parent_id ? { agentId: session.id, agentType: session.agent ?? null, description: session.title || null } : null,
+    branch: null,
+    // The archive is the rows themselves, so a reader later has what the
+    // store had — minus the reasoning parts, which OpenCode itself hides.
+    rawContent: JSON.stringify({
+      session,
+      messages,
+      parts: parts.filter((p) => !p.data.includes('"type":"reasoning"'))
+    }),
+    rawFormat: "json",
+    turns
+  };
+}
+function parseAllOpenCodeSessions(repoPath, repoId = deriveRepoId(repoPath), dbPath = opencodeDbPath()) {
+  if (!existsSync3(dbPath)) return [];
+  const sessions = sqliteJson(
+    dbPath,
+    `SELECT s.id, s.parent_id, s.directory, s.title, s.agent, s.model, s.time_created, s.time_updated, p.worktree
+       FROM session s LEFT JOIN project p ON p.id = s.project_id
+      WHERE s.time_archived IS NULL`
+  ).filter((s) => workspaceMatchesRepo(s.directory, repoPath) || workspaceMatchesRepo(s.worktree, repoPath));
+  const out = [];
+  for (const s of sessions) {
+    const messages = sqliteJson(
+      dbPath,
+      `SELECT id, session_id, time_created, data FROM message WHERE session_id = ${q(s.id)} ORDER BY time_created, id`
+    );
+    const parts = sqliteJson(
+      dbPath,
+      `SELECT id, message_id, time_created, data FROM part WHERE session_id = ${q(s.id)} ORDER BY time_created, id`
+    );
+    const parsed = buildOpenCodeSession(s, messages, parts, repoId, `${dbPath}#${s.id}`);
+    if (parsed) out.push(parsed);
+  }
+  return out;
+}
+var MAX_OUTPUT_CHARS;
+var init_opencode_sessions = __esm({
+  "../../packages/ingest-core/src/opencode-sessions.ts"() {
+    "use strict";
+    init_claude_sessions();
+    init_cursor_sessions();
+    init_derive_uuid();
+    init_git_history();
+    init_redact();
+    init_subject_linking();
+    init_types();
+    MAX_OUTPUT_CHARS = 2e3;
+  }
+});
+
+// ../../packages/ingest-core/src/copilot-sessions.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
+function copilotSessionsDir(home = homedir4()) {
+  return join4(home, ".copilot", "session-state");
+}
+function parseCopilotWorkspace(text) {
+  const map = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n")) {
+    const m = /^([a-z_]+):\s*(.*)$/.exec(line);
+    if (!m) continue;
+    let value = m[2].trim();
+    if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1).replace(/''/g, "'");
+    } else if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+      try {
+        value = JSON.parse(value);
+      } catch {
+        value = value.slice(1, -1);
+      }
+    }
+    map.set(m[1], value);
+  }
+  const get2 = (k) => {
+    const v = map.get(k);
+    return v === void 0 || v === "" || v === "null" ? null : v;
+  };
+  return {
+    id: get2("id"),
+    cwd: get2("cwd"),
+    gitRoot: get2("git_root"),
+    branch: get2("branch"),
+    name: get2("name"),
+    createdAt: get2("created_at"),
+    updatedAt: get2("updated_at")
+  };
+}
+function findCopilotSessionDirs(root = copilotSessionsDir()) {
+  if (!existsSync4(root)) return [];
+  return readdirSync2(root).map((name) => join4(root, name)).filter((dir) => {
+    try {
+      return statSync3(dir).isDirectory() && existsSync4(join4(dir, "events.jsonl"));
+    } catch {
+      return false;
+    }
+  }).sort((a, b) => statSync3(b).mtimeMs - statSync3(a).mtimeMs);
+}
+function deriveTurnId2(key) {
+  return deriveUuid(`evrex-copilot-turn ${key}`);
+}
+function filesFromTool3(tool, args) {
+  const out = [];
+  for (const key of ["path", "filePath", "file"]) {
+    const v = args[key];
+    if (typeof v === "string" && v.length > 0) out.push({ path: v, source: "tool_path", tool });
+  }
+  if (tool === "bash" && typeof args.command === "string") {
+    for (const p of extractPathsFromText(args.command)) out.push({ path: p, source: "tool_bash", tool });
+  }
+  return out;
+}
+function shutdownUsage(data, model) {
+  const details = data.tokenDetails;
+  if (!details) return { ...EMPTY_USAGE, model };
+  const n = (k) => typeof details[k]?.tokenCount === "number" ? details[k].tokenCount : null;
+  return {
+    inputTokens: n("input"),
+    outputTokens: n("output"),
+    cacheReadTokens: n("cache_read"),
+    cacheWriteTokens: n("cache_write"),
+    model
+  };
+}
+function buildCopilotSession(eventsText, workspace, repoId, sourceFile) {
+  const events = [];
+  const archived = [];
+  for (const line of eventsText.split("\n")) {
+    if (!line.trim()) continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    events.push(e);
+    if (e.data && Object.keys(e.data).some((k) => REASONING_KEYS.has(k))) {
+      const data = Object.fromEntries(Object.entries(e.data).filter(([k]) => !REASONING_KEYS.has(k)));
+      archived.push(JSON.stringify({ ...e, data }));
+    } else {
+      archived.push(line);
+    }
+  }
+  const start = events.find((e) => e.type === "session.start");
+  const startData = start?.data ?? {};
+  const sessionId = workspace.id ?? startData.sessionId ?? null;
+  if (!sessionId) return null;
+  const cwd = workspace.cwd ?? startData.context?.cwd ?? null;
+  if (!cwd) return null;
+  const turns = [];
+  let redactionCount = 0;
+  let previous = null;
+  const subjects = [];
+  let lastModel = null;
+  const push = (turn) => {
+    const redacted = redactSecrets(turn.text);
+    redactionCount += redacted.count;
+    turns.push({
+      ...turn,
+      text: redacted.text,
+      sessionId,
+      parentUuid: previous,
+      isSidechain: false,
+      redacted: redacted.count > 0,
+      editedLines: []
+    });
+    previous = turn.id;
+  };
+  const toolNames = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const d = e.data ?? {};
+    const ts = e.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
+    const id = e.id ?? deriveTurnId2(`${sessionId}:${turns.length}`);
+    switch (e.type) {
+      case "user.message": {
+        const text = typeof d.content === "string" ? d.content.trim() : "";
+        if (!text) break;
+        push({
+          id,
+          role: "user",
+          ts,
+          text,
+          filesTouched: extractPathsFromText(text).map((path) => ({ path, source: "prose" })),
+          usage: EMPTY_USAGE,
+          isSyntheticInput: false,
+          isToolError: false
+        });
+        break;
+      }
+      case "assistant.message": {
+        if (typeof d.model === "string") lastModel = d.model;
+        const text = typeof d.content === "string" ? d.content.trim() : "";
+        if (!text) break;
+        push({ id, role: "assistant", ts, text, filesTouched: [], usage: EMPTY_USAGE, isSyntheticInput: false, isToolError: false });
+        break;
+      }
+      case "tool.execution_start": {
+        const tool = typeof d.toolName === "string" ? d.toolName : "tool";
+        const callId = typeof d.toolCallId === "string" ? d.toolCallId : id;
+        const args = d.arguments && typeof d.arguments === "object" ? d.arguments : {};
+        toolNames.set(callId, tool);
+        if (tool === "bash" && typeof args.command === "string") subjects.push(...committedSubjects(args.command));
+        const rendered = JSON.stringify(args);
+        push({
+          id: deriveTurnId2(`${callId}:call`),
+          role: "assistant",
+          ts,
+          text: `[tool: ${tool}] ${rendered.length > 600 ? `${rendered.slice(0, 600)}\u2026` : rendered}`,
+          filesTouched: filesFromTool3(tool, args),
+          usage: EMPTY_USAGE,
+          isSyntheticInput: false,
+          isToolError: false
+        });
+        break;
+      }
+      case "tool.execution_complete": {
+        const callId = typeof d.toolCallId === "string" ? d.toolCallId : id;
+        const failed = d.success === false;
+        const result = d.result ?? {};
+        const error = d.error ?? {};
+        const output = (failed ? error.message ?? result.content ?? "Tool call failed" : result.content ?? "").trim();
+        push({
+          id: deriveTurnId2(`${callId}:result`),
+          role: "user",
+          ts,
+          text: output.length > MAX_OUTPUT_CHARS2 ? `${output.slice(0, MAX_OUTPUT_CHARS2)}\u2026` : output,
+          filesTouched: [],
+          usage: EMPTY_USAGE,
+          isSyntheticInput: true,
+          isToolError: failed
+        });
+        break;
+      }
+      case "session.shutdown": {
+        const usage = shutdownUsage(d, typeof d.currentModel === "string" ? d.currentModel : lastModel);
+        for (let i = turns.length - 1; i >= 0; i--) {
+          if (turns[i].role === "assistant") {
+            turns[i].usage = usage;
+            break;
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (turns.length === 0) return null;
+  const first = turns[0].ts;
+  const last = turns[turns.length - 1].ts;
+  return {
+    id: sessionId,
+    agentKind: "copilot",
+    repoId,
+    cwd,
+    startedAt: workspace.createdAt ?? startData.startTime ?? first,
+    endedAt: events[events.length - 1]?.timestamp ?? workspace.updatedAt ?? last,
+    turnCount: turns.length,
+    aiTitle: workspace.name,
+    author: null,
+    sourceFile,
+    redactionCount,
+    committedSubjects: [...new Set(subjects)],
+    parentSessionId: null,
+    subagent: null,
+    branch: workspace.branch,
+    rawContent: archived.join("\n"),
+    rawFormat: "jsonl",
+    turns
+  };
+}
+function parseCopilotSessionDir(dir, repoId) {
+  const eventsPath = join4(dir, "events.jsonl");
+  if (!existsSync4(eventsPath)) return null;
+  const workspacePath = join4(dir, "workspace.yaml");
+  const workspace = existsSync4(workspacePath) ? parseCopilotWorkspace(readFileSync2(workspacePath, "utf-8")) : parseCopilotWorkspace("");
+  return buildCopilotSession(readFileSync2(eventsPath, "utf-8"), workspace, repoId, eventsPath);
+}
+function parseAllCopilotSessions(repoPath, repoId = deriveRepoId(repoPath), root = copilotSessionsDir()) {
+  const out = [];
+  for (const dir of findCopilotSessionDirs(root)) {
+    const workspacePath = join4(dir, "workspace.yaml");
+    const workspace = existsSync4(workspacePath) ? parseCopilotWorkspace(readFileSync2(workspacePath, "utf-8")) : parseCopilotWorkspace("");
+    const known = workspace.gitRoot ?? workspace.cwd;
+    if (known && !workspaceMatchesRepo(known, repoPath)) continue;
+    const parsed = buildCopilotSession(readFileSync2(join4(dir, "events.jsonl"), "utf-8"), workspace, repoId, join4(dir, "events.jsonl"));
+    if (!parsed) continue;
+    if (!known && !workspaceMatchesRepo(parsed.cwd, repoPath)) continue;
+    out.push(parsed);
+  }
+  return out;
+}
+var MAX_OUTPUT_CHARS2, REASONING_KEYS;
+var init_copilot_sessions = __esm({
+  "../../packages/ingest-core/src/copilot-sessions.ts"() {
+    "use strict";
+    init_claude_sessions();
+    init_cursor_sessions();
+    init_derive_uuid();
+    init_git_history();
+    init_redact();
+    init_subject_linking();
+    init_types();
+    MAX_OUTPUT_CHARS2 = 2e3;
+    REASONING_KEYS = /* @__PURE__ */ new Set(["reasoningOpaque", "reasoningText", "reasoningBlocks"]);
+  }
+});
+
+// ../../packages/ingest-core/src/codex-sessions.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join5 } from "node:path";
+function codexSessionsDir() {
+  return join5(homedir5(), CODEX_DIR, "sessions");
+}
+function deriveUuid2(name) {
+  const h = createHash2("sha1").update(name).digest("hex");
+  const variant = (parseInt(h.slice(16, 17) || "0", 16) & 3 | 8).toString(16);
+  const s = h.slice(0, 12) + "5" + h.slice(13, 16) + variant + h.slice(17, 32);
+  return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20, 32)}`;
+}
+function deriveCodexTurnId(sessionId, ordinal) {
+  return deriveUuid2(`evrex-codex-turn\0${sessionId}\0${ordinal}`);
+}
+function findCodexSessionFiles(root = codexSessionsDir()) {
+  const found = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync3(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join5(dir, entry);
+      let isDir = false;
+      try {
+        isDir = statSync4(full).isDirectory();
+      } catch {
+        continue;
+      }
+      if (isDir) walk(full);
+      else if (entry.endsWith(".jsonl")) found.push(full);
+    }
+  };
+  if (existsSync5(root)) walk(root);
+  return found.sort();
+}
+function parseLines(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+function payloadType(line) {
+  const t = line.payload?.type;
+  return typeof t === "string" ? t : void 0;
 }
 function asString(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
@@ -620,7 +1935,7 @@ function filesFromToolCalls(lines) {
 function parseCodexSessionFile(filePath, repoPath, repoId) {
   let raw;
   try {
-    raw = readFileSync2(filePath, "utf-8");
+    raw = readFileSync3(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -653,6 +1968,7 @@ function parseCodexSessionFile(filePath, repoPath, repoId) {
       isSidechain: false,
       redacted: count > 0,
       isSyntheticInput: false,
+      isToolError: false,
       usage: event.usage
     };
   });
@@ -662,6 +1978,9 @@ function parseCodexSessionFile(filePath, repoPath, repoId) {
   return {
     id: sessionId,
     agentKind: "codex",
+    branch: null,
+    parentSessionId: null,
+    subagent: null,
     // Codex records the remote itself, so identity survives a moved or deleted
     // checkout. Falls back to the caller's derivation when it is absent.
     repoId: repoIdFromMeta(meta) ?? repoId,
@@ -680,9 +1999,9 @@ function parseCodexSessionFile(filePath, repoPath, repoId) {
   };
 }
 function repoIdFromMeta(meta) {
-  const git = meta.git;
-  if (typeof git !== "object" || git === null) return null;
-  const url = asString(git.repository_url);
+  const git3 = meta.git;
+  if (typeof git3 !== "object" || git3 === null) return null;
+  const url = asString(git3.repository_url);
   if (!url) return null;
   const normalized = normalizeRepoRemote(url);
   return normalized ? `remote:${normalized}` : null;
@@ -697,13 +2016,494 @@ function redactRollout(raw) {
   });
   return { content: lines.join("\n"), count };
 }
+function parseAllCodexSessions(repoPath, repoId) {
+  const sessions = [];
+  for (const file of findCodexSessionFiles()) {
+    const parsed = parseCodexSessionFile(file, repoPath, repoId);
+    if (parsed) sessions.push(parsed);
+  }
+  return sessions;
+}
+var CODEX_DIR;
+var init_codex_sessions = __esm({
+  "../../packages/ingest-core/src/codex-sessions.ts"() {
+    "use strict";
+    init_claude_sessions();
+    init_git_history();
+    init_redact();
+    init_subject_linking();
+    init_types();
+    CODEX_DIR = ".codex";
+  }
+});
 
 // ../../packages/ingest-core/src/sanitize.ts
-var NUL = String.fromCharCode(0);
+function stripNulls(value) {
+  return value.includes(NUL) ? value.split(NUL).join("") : value;
+}
+function stripNullsDeep(value) {
+  if (typeof value === "string") return stripNulls(value);
+  if (Array.isArray(value)) return value.map((v) => stripNullsDeep(v));
+  if (value && typeof value === "object") {
+    if (value instanceof Date) return value;
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = stripNullsDeep(v);
+    }
+    return out;
+  }
+  return value;
+}
+var NUL;
+var init_sanitize = __esm({
+  "../../packages/ingest-core/src/sanitize.ts"() {
+    "use strict";
+    NUL = String.fromCharCode(0);
+  }
+});
+
+// ../../packages/ingest-core/src/tickets.ts
+function deriveTicketId(args) {
+  return deriveUuid(
+    `evrex-ticket ${args.orgId} ${args.kind} ${args.workspace} ${args.externalId}`
+  );
+}
+function ticketReferencesIn(text) {
+  return [...new Set([...text.matchAll(TICKET_REFERENCE)].map((m) => m[0]))];
+}
+var TICKET_REFERENCE;
+var init_tickets = __esm({
+  "../../packages/ingest-core/src/tickets.ts"() {
+    "use strict";
+    init_derive_uuid();
+    TICKET_REFERENCE = /(?<![A-Za-z0-9_-])([A-Z][A-Z0-9]{1,9})-(\d{1,6})(?![A-Za-z0-9_-])/g;
+  }
+});
+
+// ../../packages/ingest-core/src/linear.ts
+function linearIssueToTicket(issue) {
+  if (!issue.identifier) return null;
+  const attributes = {
+    title: issue.title ?? issue.identifier,
+    status: issue.state?.name ?? null,
+    statusCategory: issue.state?.type ? STATE_TYPE[issue.state.type] ?? null : null,
+    assignee: issue.assignee?.displayName ?? null,
+    assigneeId: issue.assignee?.id ?? null,
+    team: issue.team?.key ?? null,
+    project: issue.project?.name ?? null,
+    // Linear has one kind of issue; the field exists so a Jira row and a
+    // Linear row are the same shape, which is what U5 exists to prove.
+    issueType: null,
+    // Null rather than "No priority" when the field is absent: unset and
+    // explicitly-not-prioritised are different claims.
+    priority: typeof issue.priority === "number" ? PRIORITY[issue.priority] ?? null : null,
+    // Linear records completion as a state, not as a separate resolution.
+    resolution: null
+  };
+  return {
+    externalId: issue.identifier,
+    kind: "linear",
+    url: issue.url ?? `https://linear.app/issue/${issue.identifier}`,
+    createdAt: issue.createdAt ?? null,
+    updatedAt: issue.updatedAt ?? null,
+    attributes
+  };
+}
+function linearAuthHeader(auth) {
+  if (auth.accessToken) return `Bearer ${auth.accessToken}`;
+  if (auth.apiKey) return auth.apiKey;
+  throw new Error(
+    "Linear needs either an API key or an OAuth access token; got neither."
+  );
+}
+async function fetchLinearIssues(options) {
+  const call2 = options.fetch ?? globalThis.fetch;
+  const pageSize = options.pageSize ?? 50;
+  const limit = options.limit ?? Infinity;
+  const tickets = [];
+  let after = null;
+  while (tickets.length < limit) {
+    const response = await call2(LINEAR_GRAPHQL_URL, {
+      method: "POST",
+      headers: {
+        Authorization: linearAuthHeader(options.auth),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query: LINEAR_ISSUES_QUERY,
+        variables: {
+          first: Math.min(pageSize, limit - tickets.length),
+          after
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Linear returned ${response.status} ${response.statusText}`
+      );
+    }
+    const body = await response.json();
+    if (body.errors?.length) {
+      throw new Error(
+        `Linear rejected the query: ${body.errors.map((e) => e.message).join("; ")}`
+      );
+    }
+    const page = body.data?.issues;
+    for (const node of page?.nodes ?? []) {
+      const ticket = linearIssueToTicket(node);
+      if (ticket) tickets.push(ticket);
+    }
+    if (!page?.pageInfo?.hasNextPage || !page.pageInfo.endCursor) break;
+    after = page.pageInfo.endCursor;
+  }
+  return tickets;
+}
+var LINEAR_GRAPHQL_URL, LINEAR_AUTHORIZE_URL, LINEAR_TOKEN_URL, LINEAR_READ_SCOPE, PRIORITY, STATE_TYPE, LINEAR_ISSUES_QUERY;
+var init_linear = __esm({
+  "../../packages/ingest-core/src/linear.ts"() {
+    "use strict";
+    LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
+    LINEAR_AUTHORIZE_URL = "https://linear.app/oauth/authorize";
+    LINEAR_TOKEN_URL = "https://api.linear.app/oauth/token";
+    LINEAR_READ_SCOPE = "read";
+    PRIORITY = {
+      0: "No priority",
+      1: "Urgent",
+      2: "High",
+      3: "Medium",
+      4: "Low"
+    };
+    STATE_TYPE = {
+      triage: "triage",
+      backlog: "backlog",
+      unstarted: "todo",
+      started: "in-progress",
+      completed: "done",
+      canceled: "cancelled"
+    };
+    LINEAR_ISSUES_QUERY = `
+  query EvrexIssues($first: Int!, $after: String) {
+    issues(first: $first, after: $after, orderBy: updatedAt) {
+      nodes {
+        identifier
+        title
+        url
+        priority
+        createdAt
+        updatedAt
+        state { name type }
+        assignee { id displayName }
+        team { key name }
+        project { name }
+      }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+  }
+});
+
+// ../../packages/ingest-core/src/jira.ts
+function jiraIssueToTicket(issue, siteUrl) {
+  if (!issue.key) return null;
+  const f = issue.fields ?? {};
+  const attributes = {
+    title: f.summary ?? issue.key,
+    status: f.status?.name ?? null,
+    statusCategory: f.status?.statusCategory?.key ? STATUS_CATEGORY[f.status.statusCategory.key] ?? null : null,
+    // Null when the assignee's privacy settings withhold it, which is not the
+    // same claim as an unassigned ticket — `assigneeId` distinguishes them.
+    assignee: f.assignee?.displayName ?? null,
+    assigneeId: f.assignee?.accountId ?? null,
+    // Jira has no team on an issue; the project is the closest equivalent and
+    // is reported as itself rather than smuggled into `team`.
+    team: null,
+    project: f.project?.key ?? null,
+    issueType: f.issuetype?.name ?? null,
+    priority: f.priority?.name ?? null,
+    resolution: f.resolution?.name ?? null
+  };
+  return {
+    externalId: issue.key,
+    kind: "jira",
+    url: `${siteUrl.replace(/\/+$/, "")}/browse/${issue.key}`,
+    createdAt: f.created ?? null,
+    updatedAt: f.updated ?? null,
+    attributes
+  };
+}
+function jiraBasicAuth(email, apiToken) {
+  return `Basic ${Buffer.from(`${email}:${apiToken}`).toString("base64")}`;
+}
+async function fetchJiraIssues(options) {
+  const call2 = options.fetch ?? globalThis.fetch;
+  const site = options.siteUrl.replace(/\/+$/, "");
+  const pageSize = options.pageSize ?? 100;
+  const limit = options.limit ?? Infinity;
+  const jql = options.jql ?? "ORDER BY updated DESC";
+  const tickets = [];
+  let nextPageToken = null;
+  while (tickets.length < limit) {
+    const response = await call2(`${site}${JIRA_SEARCH_PATH}`, {
+      method: "POST",
+      headers: {
+        Authorization: jiraBasicAuth(options.email, options.apiToken),
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify({
+        jql,
+        fields: [...JIRA_FIELDS],
+        maxResults: Math.min(pageSize, limit - tickets.length),
+        ...nextPageToken ? { nextPageToken } : {}
+      })
+    });
+    if (!response.ok) {
+      const hint = response.status === 410 ? ` \u2014 that is what the removed /rest/api/3/search returns; this client uses ${JIRA_SEARCH_PATH}` : "";
+      throw new Error(
+        `Jira returned ${response.status} ${response.statusText}${hint}`
+      );
+    }
+    const body = await response.json();
+    for (const issue of body.issues ?? []) {
+      const ticket = jiraIssueToTicket(issue, site);
+      if (ticket) tickets.push(ticket);
+    }
+    if (!body.nextPageToken) break;
+    nextPageToken = body.nextPageToken;
+  }
+  return tickets;
+}
+var JIRA_SEARCH_PATH, JIRA_FIELDS, STATUS_CATEGORY;
+var init_jira = __esm({
+  "../../packages/ingest-core/src/jira.ts"() {
+    "use strict";
+    JIRA_SEARCH_PATH = "/rest/api/3/search/jql";
+    JIRA_FIELDS = [
+      "summary",
+      "status",
+      "assignee",
+      "resolution",
+      "created",
+      "updated",
+      "project",
+      "issuetype",
+      "priority"
+    ];
+    STATUS_CATEGORY = {
+      new: "todo",
+      indeterminate: "in-progress",
+      done: "done"
+    };
+  }
+});
+
+// ../../packages/ingest-core/src/diff-parser.ts
+function parseUnifiedDiffHunks(diffText) {
+  const hunks = [];
+  let current = null;
+  for (const line of diffText.split("\n")) {
+    if (HUNK_HEADER_RE.test(line)) {
+      current = { header: line, lines: [] };
+      hunks.push(current);
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("+")) {
+      current.lines.push({ kind: "add", text: line.slice(1) });
+    } else if (line.startsWith("-")) {
+      current.lines.push({ kind: "del", text: line.slice(1) });
+    } else if (line.startsWith(" ")) {
+      current.lines.push({ kind: "ctx", text: line.slice(1) });
+    }
+  }
+  return hunks;
+}
+var HUNK_HEADER_RE;
+var init_diff_parser = __esm({
+  "../../packages/ingest-core/src/diff-parser.ts"() {
+    "use strict";
+    HUNK_HEADER_RE = /^@@ .+? @@.*$/;
+  }
+});
+
+// ../../packages/ingest-core/src/trace-lines.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+function isHunkHeader(line) {
+  return line.startsWith("@@");
+}
+function parseLineLog(raw) {
+  const commits = [];
+  let current = null;
+  let hunk = null;
+  const closeHunk = () => {
+    if (current && hunk) current.hunks.push(hunk);
+    hunk = null;
+  };
+  for (const line of raw.split("\n")) {
+    if (line.startsWith(COMMIT_MARK)) {
+      closeHunk();
+      const [sha, at, author, ...rest] = line.slice(COMMIT_MARK.length).split(FIELD_SEP2);
+      if (!sha || !at) {
+        current = null;
+        continue;
+      }
+      current = {
+        sha,
+        at,
+        author: author ?? "",
+        subject: rest.join(FIELD_SEP2),
+        hunks: [],
+        createdFile: false
+      };
+      commits.push(current);
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("--- ")) {
+      if (line.trim() === "--- /dev/null") current.createdFile = true;
+      continue;
+    }
+    if (line.startsWith("+++ ") || line.startsWith("diff --git ")) continue;
+    if (isHunkHeader(line)) {
+      closeHunk();
+      hunk = { header: line, lines: [] };
+      continue;
+    }
+    if (hunk && (line.startsWith(" ") || line.startsWith("+") || line.startsWith("-"))) {
+      hunk.lines.push(line);
+    }
+  }
+  closeHunk();
+  return commits;
+}
+function detectTruncatedHistory(commits, repoPath) {
+  const oldest = commits[commits.length - 1];
+  if (!oldest) return false;
+  const added = oldest.hunks.flatMap((h) => h.lines).filter((l) => l.startsWith("+")).map((l) => l.slice(1).trim()).filter((l) => l.length >= MOVED_LINE_MIN_LENGTH);
+  const body = oldest.hunks.flatMap((h) => h.lines);
+  if (body.length === 0 || !body.every((l) => l.startsWith("+"))) return false;
+  if (added.length === 0 || !repoPath) return false;
+  const removedElsewhere = deletedLinesElsewhere(repoPath, oldest.sha);
+  if (removedElsewhere.size === 0) return false;
+  const matched = added.filter((l) => removedElsewhere.has(l)).length;
+  return matched / added.length >= MOVED_LINE_FRACTION;
+}
+function deletedLinesElsewhere(repoPath, sha) {
+  const out = /* @__PURE__ */ new Set();
+  let raw;
+  try {
+    raw = execFileSync3(
+      "git",
+      [
+        "show",
+        "--format=",
+        "--unified=0",
+        "--no-color",
+        // Without this git collapses a delete-plus-identical-add into
+        // "rename from/to" with no line content at all — so the very case
+        // this function exists to detect would produce nothing to match.
+        "--no-renames",
+        sha
+      ],
+      {
+        cwd: repoPath,
+        maxBuffer: 1024 * 1024 * 64,
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).toString("utf-8");
+  } catch {
+    return out;
+  }
+  for (const line of raw.split("\n")) {
+    if (!line.startsWith("-") || line.startsWith("---")) continue;
+    const text = line.slice(1).trim();
+    if (text.length >= MOVED_LINE_MIN_LENGTH) out.add(text);
+  }
+  return out;
+}
+function committedLineCount(repoPath, file, rev = "HEAD") {
+  try {
+    const out = execFileSync3("git", ["show", `${rev}:${file}`], {
+      cwd: repoPath,
+      maxBuffer: 1024 * 1024 * 64,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString("utf-8");
+    const lines = out.split("\n");
+    const count = lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+    return count > 0 ? count : null;
+  } catch {
+    return null;
+  }
+}
+function traceLines(repoPath, file, from, to, rev) {
+  const start = Math.max(MIN_LINE, Math.floor(from));
+  const end = to <= 0 ? committedLineCount(repoPath, file, rev) ?? Math.max(start, 1) : Math.max(start, Math.floor(to));
+  let raw;
+  try {
+    raw = execFileSync3(
+      "git",
+      [
+        "log",
+        // argv array, never a shell string: `file` is caller-supplied and can
+        // legitimately contain spaces, quotes or a leading dash.
+        `-L${start},${end}:${file}`,
+        `--format=${COMMIT_MARK}%H${FIELD_SEP2}%aI${FIELD_SEP2}%an${FIELD_SEP2}%s`,
+        // Anchors the walk at the revision the caller's line numbers came
+        // from. Omitted, git starts at HEAD, which is right for a working-copy
+        // selection and wrong for one taken from an old diff.
+        ...rev ? [rev] : []
+      ],
+      {
+        cwd: repoPath,
+        maxBuffer: 1024 * 1024 * 64,
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).toString("utf-8");
+  } catch {
+    return { commits: [], historyMayBeTruncated: false };
+  }
+  const commits = parseLineLog(raw);
+  return {
+    commits,
+    historyMayBeTruncated: detectTruncatedHistory(commits, repoPath)
+  };
+}
+var COMMIT_MARK, FIELD_SEP2, MIN_LINE, MOVED_LINE_MIN_LENGTH, MOVED_LINE_FRACTION;
+var init_trace_lines = __esm({
+  "../../packages/ingest-core/src/trace-lines.ts"() {
+    "use strict";
+    COMMIT_MARK = "@@EVREX-COMMIT@@";
+    FIELD_SEP2 = "";
+    MIN_LINE = 1;
+    MOVED_LINE_MIN_LENGTH = 6;
+    MOVED_LINE_FRACTION = 0.5;
+  }
+});
+
+// ../../packages/ingest-core/src/trace-target.ts
+function parseTraceTarget(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const match = /^(.*?):(\d+)(?:\s*[-\u2013:]\s*(\d+))?$/.exec(trimmed);
+  if (!match) return null;
+  const [, file, fromText, toText] = match;
+  if (!file) return null;
+  const from = Number(fromText);
+  const to = toText ? Number(toText) : from;
+  if (!Number.isFinite(from) || from < 1) return null;
+  if (!Number.isFinite(to) || to < 1) return null;
+  return { file, from: Math.min(from, to), to: Math.max(from, to) };
+}
+var init_trace_target = __esm({
+  "../../packages/ingest-core/src/trace-target.ts"() {
+    "use strict";
+  }
+});
 
 // ../../packages/ingest-core/src/gemini-sessions.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-var SYNTHETIC = /^\s*<session_context>/;
+import { readFileSync as readFileSync4 } from "node:fs";
 function textOf(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -714,7 +2514,7 @@ function textOf(content) {
 function parseGeminiSessionFile(filePath, repoPath, repoId) {
   let raw;
   try {
-    raw = readFileSync3(filePath, "utf-8");
+    raw = readFileSync4(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -760,6 +2560,7 @@ function parseGeminiSessionFile(filePath, repoPath, repoId) {
       // as a user message. Attributing that to the person is the same bug this
       // repo already fixed once for Claude Code's tool results.
       isSyntheticInput: role === "user" && SYNTHETIC.test(text),
+      isToolError: false,
       // Gemini records a model per message but no token counts in the
       // transcript; unknown rather than zero.
       usage: { ...EMPTY_USAGE, model: record.model ?? null }
@@ -783,12 +2584,24 @@ function parseGeminiSessionFile(filePath, repoPath, repoId) {
     redactionCount: redactionCount + rawRedactions,
     turns,
     rawContent,
+    branch: null,
+    parentSessionId: null,
+    subagent: null,
     rawFormat: "jsonl"
   };
 }
+var SYNTHETIC;
+var init_gemini_sessions = __esm({
+  "../../packages/ingest-core/src/gemini-sessions.ts"() {
+    "use strict";
+    init_derive_uuid();
+    init_redact();
+    init_types();
+    SYNTHETIC = /^\s*<session_context>/;
+  }
+});
 
 // ../../packages/ingest-core/src/transcript-parsers.ts
-var PARSERS = [parseSessionFile, parseCodexSessionFile, parseGeminiSessionFile];
 function parseTranscriptFile(path, repoPath, repoId) {
   for (const parse of PARSERS) {
     const parsed = parse(path, repoPath, repoId);
@@ -796,21 +2609,600 @@ function parseTranscriptFile(path, repoPath, repoId) {
   }
   return null;
 }
+var PARSERS;
+var init_transcript_parsers = __esm({
+  "../../packages/ingest-core/src/transcript-parsers.ts"() {
+    "use strict";
+    init_claude_sessions();
+    init_codex_sessions();
+    init_gemini_sessions();
+    PARSERS = [parseSessionFile, parseCodexSessionFile, parseGeminiSessionFile];
+  }
+});
+
+// ../../packages/ingest-core/src/slack-threads.ts
+function displayName(users, id) {
+  if (!id) return "unknown";
+  const user = users.get(id);
+  return user?.profile?.real_name ?? user?.real_name ?? user?.profile?.display_name ?? user?.name ?? id;
+}
+function slackTimestamp(ts) {
+  const seconds = Number(ts);
+  if (!Number.isFinite(seconds) || seconds <= 0) return null;
+  return new Date(seconds * 1e3).toISOString();
+}
+function readableText(text, users) {
+  return text.replace(/<@([A-Z0-9]+)(?:\|[^>]*)?>/g, (_, id) => `@${displayName(users, id)}`).replace(/<#[A-Z0-9]+\|([^>]*)>/g, (_, name) => `#${name}`).replace(/<(https?:[^>|]+)\|([^>]*)>/g, (_, __, label) => label).replace(/<(https?:[^>]+)>/g, (_, url) => url).replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+}
+function isHumanMessage(message) {
+  if (message.type && message.type !== "message") return false;
+  if (message.subtype && MACHINE_SUBTYPES.has(message.subtype)) return false;
+  if (message.bot_id && !message.user) return false;
+  return Boolean(message.text?.trim());
+}
+function groupIntoThreads(messages) {
+  const threads = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (!isHumanMessage(message)) continue;
+    const key = message.thread_ts ?? message.ts;
+    if (!key) continue;
+    threads.set(key, [...threads.get(key) ?? [], message]);
+  }
+  return [...threads.values()].map(
+    (thread) => [...thread].sort((a, b) => Number(a.ts ?? 0) - Number(b.ts ?? 0))
+  );
+}
+function parseSlackExport(messages, options) {
+  const users = /* @__PURE__ */ new Map();
+  for (const user of options.users ?? []) if (user.id) users.set(user.id, user);
+  const out = [];
+  for (const thread of groupIntoThreads(messages)) {
+    const root = thread[0];
+    const rootTs = root?.thread_ts ?? root?.ts;
+    const startedAt = slackTimestamp(rootTs ?? void 0);
+    if (!rootTs || !startedAt) continue;
+    const turns = [];
+    let redactionCount = 0;
+    for (const message of thread) {
+      const ts = slackTimestamp(message.ts);
+      if (!ts) continue;
+      const { text, count } = redactSecrets(
+        readableText(message.text ?? "", users)
+      );
+      if (!text.trim()) continue;
+      redactionCount += count;
+      turns.push({
+        // A uuid, because that is what the columns these land in are. The
+        // readable `slack:<channel>:<ts>` key is kept on `sourceFile`.
+        id: deriveSlackTurnId(options.channel, message.ts),
+        sessionId: deriveSlackSessionId(options.channel, rootTs),
+        // Everything here was typed by a person. There is no assistant side,
+        // and marking any of it otherwise would let it be read as recovered
+        // agent reasoning.
+        role: "user",
+        ts,
+        text: `${displayName(users, message.user)}: ${text}`,
+        filesTouched: [],
+        editedLines: [],
+        parentUuid: null,
+        isSidechain: false,
+        redacted: count > 0,
+        isSyntheticInput: false,
+        isToolError: false,
+        // Neither source reports what a turn cost, so it is unknown rather than free.
+        usage: { ...EMPTY_USAGE }
+      });
+    }
+    const size = turns.reduce((total, turn) => total + turn.text.length, 0);
+    if (turns.length < MIN_THREAD_MESSAGES) continue;
+    const floor = turns.length === 1 ? MIN_SOLO_CHARS : MIN_THREAD_CHARS;
+    if (size < floor) continue;
+    out.push({
+      session: {
+        id: deriveSlackSessionId(options.channel, rootTs),
+        agentKind: "slack",
+        repoId: options.repoId,
+        cwd: options.cwd,
+        startedAt,
+        endedAt: turns[turns.length - 1]?.ts ?? startedAt,
+        turnCount: turns.length,
+        // The first message is what the thread is about, near enough, and it
+        // is what Slack itself shows in a thread list.
+        aiTitle: (turns[0]?.text ?? "").slice(0, 120),
+        author: displayName(users, root?.user),
+        sourceFile: `slack/${options.channel}/${rootTs}.json`,
+        redactionCount,
+        // The thread exactly as Slack gave it, redacted like every other
+        // archived transcript: a teammate re-materialising this must not
+        // receive a key the author pasted into a channel.
+        // A Slack thread runs no commands; nothing here can place a commit.
+        committedSubjects: [],
+        rawContent: JSON.stringify(
+          thread.map((message) => ({
+            ...message,
+            text: redactSecrets(message.text ?? "").text
+          })),
+          null,
+          2
+        ),
+        branch: null,
+        parentSessionId: null,
+        subagent: null,
+        rawFormat: "json",
+        turns
+      },
+      turns
+    });
+  }
+  return out;
+}
+var MIN_THREAD_MESSAGES, MIN_THREAD_CHARS, MIN_SOLO_CHARS, MACHINE_SUBTYPES;
+var init_slack_threads = __esm({
+  "../../packages/ingest-core/src/slack-threads.ts"() {
+    "use strict";
+    init_redact();
+    init_derive_uuid();
+    init_types();
+    MIN_THREAD_MESSAGES = 1;
+    MIN_THREAD_CHARS = 80;
+    MIN_SOLO_CHARS = 200;
+    MACHINE_SUBTYPES = /* @__PURE__ */ new Set([
+      "channel_join",
+      "channel_leave",
+      "channel_topic",
+      "channel_purpose",
+      "channel_name",
+      "channel_archive",
+      "channel_unarchive",
+      "bot_message",
+      "thread_broadcast_join"
+    ]);
+  }
+});
+
+// ../../packages/ingest-core/src/slack-client.ts
+async function call(method, params, options, attempt = 0) {
+  const doFetch = options.fetchImpl ?? fetch;
+  const sleep = options.sleep ?? wait;
+  const query = new URLSearchParams(params).toString();
+  const response = options.post ? await doFetch(`${API}/${method}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${options.token}`,
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: query
+  }) : await doFetch(`${API}/${method}?${query}`, {
+    headers: { Authorization: `Bearer ${options.token}` }
+  });
+  if (response.status === 429 && attempt < 5) {
+    const header = response.headers.get("retry-after");
+    const seconds = header ? Number(header) : NaN;
+    await sleep((Number.isFinite(seconds) ? seconds : 30) * 1e3);
+    return call(method, params, options, attempt + 1);
+  }
+  const body = await response.json();
+  if (!body.ok) {
+    const code = body.error ?? `http_${response.status}`;
+    throw new SlackError(code, PERMANENT.has(code));
+  }
+  return body;
+}
+async function paginate(method, params, pick, options) {
+  const out = [];
+  let cursor;
+  do {
+    const body = await call(
+      method,
+      { ...params, limit: String(PAGE_SIZE), ...cursor ? { cursor } : {} },
+      options
+    );
+    out.push(...pick(body) ?? []);
+    cursor = body.response_metadata?.next_cursor || void 0;
+  } while (cursor);
+  return out;
+}
+async function listChannels(options) {
+  const channels = await paginate(
+    "conversations.list",
+    { types: "public_channel,private_channel", exclude_archived: "true" },
+    (body) => body.channels,
+    options
+  );
+  return channels.filter(
+    (channel) => !channel.is_private || channel.is_member !== false
+  );
+}
+async function joinChannel(channel, options) {
+  await call("conversations.join", { channel }, { ...options, post: true });
+}
+async function postMessage(channel, text, options) {
+  await call(
+    "chat.postMessage",
+    { channel, text, unfurl_links: "false", unfurl_media: "false" },
+    { ...options, post: true }
+  );
+}
+async function listUsers(options) {
+  return paginate("users.list", {}, (body) => body.members, options);
+}
+async function fetchChannelMessages(channel, options) {
+  const top = await paginate(
+    "conversations.history",
+    { channel, ...options.oldest ? { oldest: options.oldest } : {} },
+    (body) => body.messages,
+    options
+  );
+  const all = [];
+  for (const message of top) {
+    all.push(message);
+    const replyCount = message.reply_count ?? 0;
+    if (replyCount > 0 && message.ts) {
+      options.onProgress?.(`reading a thread with ${replyCount} replies`);
+      const replies = await paginate(
+        "conversations.replies",
+        { channel, ts: message.ts },
+        (body) => body.messages,
+        options
+      );
+      all.push(...replies.filter((reply) => reply.ts !== message.ts));
+    }
+  }
+  return all;
+}
+var API, PAGE_SIZE, PERMANENT, SlackError, wait;
+var init_slack_client = __esm({
+  "../../packages/ingest-core/src/slack-client.ts"() {
+    "use strict";
+    API = "https://slack.com/api";
+    PAGE_SIZE = 200;
+    PERMANENT = /* @__PURE__ */ new Set([
+      "invalid_auth",
+      "account_inactive",
+      "token_revoked",
+      "missing_scope",
+      "not_allowed_token_type"
+    ]);
+    SlackError = class extends Error {
+      constructor(slackCode, permanent) {
+        super(`Slack returned ${slackCode}`);
+        this.slackCode = slackCode;
+        this.permanent = permanent;
+        this.name = "SlackError";
+      }
+    };
+    wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  }
+});
+
+// ../../packages/ingest-core/src/line-survival.ts
+import { execFileSync as execFileSync4 } from "node:child_process";
+function git2(repoPath, args) {
+  return execFileSync4("git", args, {
+    cwd: repoPath,
+    maxBuffer: 1024 * 1024 * 64,
+    stdio: ["ignore", "pipe", "ignore"]
+  }).toString("utf-8");
+}
+function addedByFile(repoPath, sha) {
+  const out = /* @__PURE__ */ new Map();
+  const raw = git2(repoPath, ["diff-tree", "--root", "--no-commit-id", "--numstat", "-r", "-M", sha]);
+  for (const line of raw.split("\n")) {
+    const [added, , path] = line.split("	");
+    if (!path || added === "-") continue;
+    out.set(path, Number(added) || 0);
+  }
+  return out;
+}
+function survivingIn(repoPath, sha, path) {
+  let raw;
+  try {
+    raw = git2(repoPath, ["blame", "-w", "-M", "--line-porcelain", "HEAD", "--", path]);
+  } catch {
+    return 0;
+  }
+  let n = 0;
+  for (const line of raw.split("\n")) {
+    if (line.length > 41 && line.charCodeAt(0) !== 9 && line.startsWith(sha.slice(0, 40)) && line[40] === " ") {
+      n += 1;
+    }
+  }
+  return n;
+}
+function measureLineSurvival(repoPath, sha, now = /* @__PURE__ */ new Date()) {
+  const full = git2(repoPath, ["rev-parse", sha]).trim();
+  const added = addedByFile(repoPath, full);
+  let addedLines = 0;
+  let survivingLines = 0;
+  for (const [path, n] of added) {
+    addedLines += n;
+    if (n > 0) survivingLines += survivingIn(repoPath, full, path);
+  }
+  return { sha: full, addedLines, survivingLines: Math.min(survivingLines, addedLines), measuredAt: now.toISOString() };
+}
+function commitsOlderThan(repoPath, minAgeDays, limit, now = /* @__PURE__ */ new Date()) {
+  const before = new Date(now.getTime() - minAgeDays * 864e5).toISOString();
+  const raw = git2(repoPath, ["log", `--before=${before}`, `--max-count=${limit}`, "--format=%H%x09%cI", "HEAD"]);
+  return raw.split("\n").filter(Boolean).map((line) => {
+    const [sha, at] = line.split("	");
+    return { sha, at };
+  });
+}
+var init_line_survival = __esm({
+  "../../packages/ingest-core/src/line-survival.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/ingest-core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CONVERSATION_KINDS: () => CONVERSATION_KINDS,
+  EMPTY_USAGE: () => EMPTY_USAGE,
+  EVREX_ORIGIN_TRAILER_KEY: () => EVREX_ORIGIN_TRAILER_KEY,
+  EVREX_SESSION_TRAILER_KEY: () => EVREX_SESSION_TRAILER_KEY,
+  JIRA_FIELDS: () => JIRA_FIELDS,
+  JIRA_SEARCH_PATH: () => JIRA_SEARCH_PATH,
+  LINEAR_AUTHORIZE_URL: () => LINEAR_AUTHORIZE_URL,
+  LINEAR_GRAPHQL_URL: () => LINEAR_GRAPHQL_URL,
+  LINEAR_ISSUES_QUERY: () => LINEAR_ISSUES_QUERY,
+  LINEAR_READ_SCOPE: () => LINEAR_READ_SCOPE,
+  LINEAR_TOKEN_URL: () => LINEAR_TOKEN_URL,
+  MIN_MEANINGFUL_LINE_LENGTH: () => MIN_MEANINGFUL_LINE_LENGTH,
+  PARSER_VERSION: () => PARSER_VERSION,
+  PROVENANCE_TRAILERS: () => PROVENANCE_TRAILERS,
+  REFERENCE_KINDS: () => REFERENCE_KINDS,
+  SOURCE_KINDS: () => SOURCE_KINDS,
+  STATED_TRAILERS: () => STATED_TRAILERS,
+  SlackError: () => SlackError,
+  advanceCursor: () => advanceCursor,
+  agentTrailersOf: () => agentTrailersOf,
+  buildCopilotSession: () => buildCopilotSession,
+  buildOpenCodeSession: () => buildOpenCodeSession,
+  changedSessions: () => changedSessions,
+  codexSessionsDir: () => codexSessionsDir,
+  collectRepoData: () => collectRepoData,
+  commitsOlderThan: () => commitsOlderThan,
+  committedSubjects: () => committedSubjects,
+  copilotSessionsDir: () => copilotSessionsDir,
+  cursorStateDbPath: () => cursorStateDbPath,
+  deriveCodexTurnId: () => deriveCodexTurnId,
+  deriveCursorSessionId: () => deriveCursorSessionId,
+  deriveOpenCodeSessionId: () => deriveOpenCodeSessionId,
+  deriveRepoId: () => deriveRepoId,
+  deriveSlackSessionId: () => deriveSlackSessionId,
+  deriveSlackTurnId: () => deriveSlackTurnId,
+  deriveTicketId: () => deriveTicketId,
+  deriveUuid: () => deriveUuid,
+  detectTruncatedHistory: () => detectTruncatedHistory,
+  fetchChannelMessages: () => fetchChannelMessages,
+  fetchJiraIssues: () => fetchJiraIssues,
+  fetchLinearIssues: () => fetchLinearIssues,
+  findCodexSessionFiles: () => findCodexSessionFiles,
+  findCopilotSessionDirs: () => findCopilotSessionDirs,
+  findSessionFiles: () => findSessionFiles,
+  getGitUserName: () => getGitUserName,
+  groupIntoThreads: () => groupIntoThreads,
+  isHumanMessage: () => isHumanMessage,
+  isReferenceKind: () => isReferenceKind,
+  jiraBasicAuth: () => jiraBasicAuth,
+  jiraIssueToTicket: () => jiraIssueToTicket,
+  joinChannel: () => joinChannel,
+  lacksFileAttribution: () => lacksFileAttribution,
+  linearAuthHeader: () => linearAuthHeader,
+  linearIssueToTicket: () => linearIssueToTicket,
+  listChannels: () => listChannels,
+  listUsers: () => listUsers,
+  loadComposers: () => loadComposers,
+  matchCommitToSession: () => matchCommitToSession,
+  measureLineSurvival: () => measureLineSurvival,
+  normalizeRepoRemote: () => normalizeRepoRemote,
+  opencodeDbPath: () => opencodeDbPath,
+  originOf: () => originOf,
+  parseAllCodexSessions: () => parseAllCodexSessions,
+  parseAllCopilotSessions: () => parseAllCopilotSessions,
+  parseAllCursorSessions: () => parseAllCursorSessions,
+  parseAllOpenCodeSessions: () => parseAllOpenCodeSessions,
+  parseAllSessions: () => parseAllSessions,
+  parseCodexSessionFile: () => parseCodexSessionFile,
+  parseCopilotSessionDir: () => parseCopilotSessionDir,
+  parseCopilotWorkspace: () => parseCopilotWorkspace,
+  parseCursorComposer: () => parseCursorComposer,
+  parseCursorConversation: () => parseCursorConversation,
+  parseGeminiSessionFile: () => parseGeminiSessionFile,
+  parseGitLog: () => parseGitLog,
+  parseLineLog: () => parseLineLog,
+  parseSessionFile: () => parseSessionFile,
+  parseSlackExport: () => parseSlackExport,
+  parseTraceTarget: () => parseTraceTarget,
+  parseTrailers: () => parseTrailers,
+  parseTranscriptFile: () => parseTranscriptFile,
+  parseUnifiedDiffHunks: () => parseUnifiedDiffHunks,
+  planRead: () => planRead,
+  postMessage: () => postMessage,
+  proposeLinks: () => proposeLinks,
+  provenanceTrailerFor: () => provenanceTrailerFor,
+  readableText: () => readableText,
+  redactJsonValue: () => redactJsonValue,
+  redactRawTranscript: () => redactRawTranscript,
+  redactSecrets: () => redactSecrets,
+  repoIdFromPath: () => repoIdFromPath,
+  repoIdFromRemote: () => repoIdFromRemote,
+  repoIdFromRootCommit: () => repoIdFromRootCommit,
+  repoNameFromId: () => repoNameFromId,
+  sessionSignature: () => sessionSignature,
+  slackTimestamp: () => slackTimestamp,
+  splitCompleteLines: () => splitCompleteLines,
+  statedInsightsOf: () => statedInsightsOf,
+  stripNulls: () => stripNulls,
+  stripNullsDeep: () => stripNullsDeep,
+  ticketReferencesIn: () => ticketReferencesIn,
+  traceLines: () => traceLines,
+  trailersFromMessage: () => trailersFromMessage
+});
+import { userInfo } from "node:os";
+function resolveFallbackAuthor(repoPath, commits) {
+  const configured = getGitUserName(repoPath);
+  if (configured) return configured;
+  const counts = /* @__PURE__ */ new Map();
+  for (const c of commits) {
+    if (!c.author) continue;
+    counts.set(c.author, (counts.get(c.author) ?? 0) + 1);
+  }
+  const mostFrequent = [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+  if (mostFrequent) return mostFrequent;
+  try {
+    return userInfo().username || null;
+  } catch {
+    return null;
+  }
+}
+function collectRepoData(repoPath, options = {}) {
+  const repoId = deriveRepoId(repoPath);
+  const commits = parseGitLog(repoPath, repoId, options.knownCommits);
+  const author = resolveFallbackAuthor(repoPath, commits);
+  const claude = parseAllSessions(repoPath, repoId, options.cursors ?? {});
+  const sessions = [
+    ...claude.sessions,
+    ...parseAllCursorSessions(repoPath, repoId),
+    ...parseAllCodexSessions(repoPath, repoId),
+    ...parseAllOpenCodeSessions(repoPath, repoId),
+    ...parseAllCopilotSessions(repoPath, repoId)
+  ].map((s) => ({
+    ...s,
+    author: s.author ?? author
+  }));
+  const totalRedactions = sessions.reduce((sum, s) => sum + s.redactionCount, 0);
+  return {
+    sessions: stripNullsDeep(sessions),
+    commits: stripNullsDeep(commits),
+    totalRedactions,
+    cursors: claude.cursors,
+    skippedTranscripts: claude.skipped
+  };
+}
+var init_src = __esm({
+  "../../packages/ingest-core/src/index.ts"() {
+    "use strict";
+    init_git_history();
+    init_claude_sessions();
+    init_cursor_sessions();
+    init_opencode_sessions();
+    init_copilot_sessions();
+    init_codex_sessions();
+    init_sanitize();
+    init_types();
+    init_sanitize();
+    init_incremental();
+    init_redact();
+    init_tickets();
+    init_linear();
+    init_jira();
+    init_claude_sessions();
+    init_copilot_sessions();
+    init_opencode_sessions();
+    init_cursor_sessions();
+    init_codex_sessions();
+    init_git_history();
+    init_diff_parser();
+    init_trace_lines();
+    init_trace_target();
+    init_transcript_parsers();
+    init_gemini_sessions();
+    init_slack_threads();
+    init_slack_client();
+    init_subject_linking();
+    init_derive_uuid();
+    init_line_survival();
+  }
+});
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  evrexApi: () => evrexApi
+});
+function headers() {
+  const base = { "Content-Type": "application/json" };
+  if (EVREX_TOKEN) base.Authorization = `Bearer ${EVREX_TOKEN}`;
+  return base;
+}
+function describeFailure(method, path, status, statusText) {
+  if (status === 401 || status === 403) {
+    return EVREX_TOKEN ? `${method} ${path} -> ${status}: the EVREX_TOKEN this server was started with was rejected. It may be revoked or expired.` : `${method} ${path} -> ${status}: this evrex backend requires a credential, but no EVREX_TOKEN is set for this MCP server.`;
+  }
+  return `${method} ${path} -> ${status} ${statusText}`;
+}
+async function request(method, path, { body, absentIsAnswer } = {}) {
+  const res = await fetch(`${API_BASE_URL}${path}`, {
+    method,
+    headers: headers(),
+    ...body === void 0 ? {} : { body: JSON.stringify(body) }
+  });
+  if (res.status === 404 && absentIsAnswer) return null;
+  if (!res.ok) throw new Error(describeFailure(method, path, res.status, res.statusText));
+  return await res.json();
+}
+var DEFAULT_API_BASE_URL, API_BASE_URL, EVREX_TOKEN, get, getOrNull, post, evrexApi;
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    DEFAULT_API_BASE_URL = "https://api.evrex.ai";
+    API_BASE_URL = (process.env.EVREX_API_BASE_URL ?? process.env.EVREX_API_URL ?? DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+    EVREX_TOKEN = process.env.EVREX_TOKEN ?? process.env.EVREX_API_TOKEN ?? null;
+    get = (path) => request("GET", path);
+    getOrNull = (path) => request("GET", path, { absentIsAnswer: true });
+    post = (path, body) => request("POST", path, { body });
+    evrexApi = {
+      baseUrl: API_BASE_URL,
+      repos: () => get("/repos"),
+      commits: (repoPath) => get(`/commits?repoPath=${encodeURIComponent(repoPath)}`),
+      // Abbreviated shas resolve server-side, so a value pasted from `git log`
+      // works here (apps/backend/src/reads/reads.service.ts#resolveSha).
+      commit: (sha) => getOrNull(`/commits/${encodeURIComponent(sha)}`),
+      sessions: (repoPath) => get(`/sessions?repoPath=${encodeURIComponent(repoPath)}`),
+      session: (id) => getOrNull(`/sessions/${encodeURIComponent(id)}`),
+      // The paginated transcript — see reads.service.ts#getSessionTurns. `ts, id`
+      // ordering server-side makes offsets stable across requests.
+      sessionTurns: (id, offset, limit) => getOrNull(
+        `/sessions/${encodeURIComponent(id)}/turns?offset=${offset}&limit=${limit}`
+      ),
+      ask: (repoPath, text, filePaths) => post("/ask", { repoPath, text, filePaths }),
+      // Evidence-only retrieval (BM25 + embedding), no LLM synthesis call — see
+      // apps/backend/src/query/query.service.ts#search. Used by evrex_search,
+      // which wants ranked hits fast, not a synthesized paragraph.
+      search: (repoPath, text, filePaths) => post("/search", { repoPath, text, filePaths }),
+      // Everything that happened in a repo, newest first, bounded by days — the
+      // same query the desktop Timeline screen makes. Sessions and commits
+      // interleaved, each with the handle evrex_expand takes.
+      feedback: (body) => post("/feedback", body),
+      timeline: (repoPath, days) => get(
+        `/timeline?repoPath=${encodeURIComponent(repoPath)}&days=${encodeURIComponent(String(days))}`
+      )
+    };
+  }
+});
+
+// src/capture.ts
+init_src();
+import { statSync as statSync5 } from "node:fs";
+import { homedir as homedir7, hostname } from "node:os";
+import { dirname as dirname3, join as join7 } from "node:path";
 
 // src/capture-state.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync4, renameSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { existsSync as existsSync6, mkdirSync, readFileSync as readFileSync5, renameSync, writeFileSync } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { dirname, join as join6 } from "node:path";
 var EMPTY = { sessions: {} };
-function stateDir(home = homedir()) {
-  return join(home, ".evrex");
+function stateDir(home = homedir6()) {
+  return join6(home, ".evrex");
 }
-function statePath(home = homedir()) {
-  return join(stateDir(home), "capture-state.json");
+function statePath(home = homedir6()) {
+  return join6(stateDir(home), "capture-state.json");
 }
 function readState(path) {
   try {
-    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
     if (!parsed || typeof parsed !== "object" || typeof parsed.sessions !== "object") {
       return { sessions: {} };
     }
@@ -829,17 +3221,17 @@ function writeState(path, state) {
   }
 }
 function orphaned(state, exceptSessionId) {
-  return Object.entries(state.sessions).filter(([id, s]) => !s.archived && id !== exceptSessionId).map(([, s]) => s).filter((s) => existsSync3(s.transcriptPath));
+  return Object.entries(state.sessions).filter(([id, s]) => !s.archived && id !== exceptSessionId).map(([, s]) => s).filter((s) => existsSync6(s.transcriptPath));
 }
 
 // src/spool.ts
-import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname2 } from "node:path";
 var MAX_SPOOL_BYTES = 32 * 1024 * 1024;
 function append(spoolPath, post2) {
   try {
     mkdirSync2(dirname2(spoolPath), { recursive: true });
-    if (existsSync4(spoolPath) && sizeOf(spoolPath) >= MAX_SPOOL_BYTES) return;
+    if (existsSync7(spoolPath) && sizeOf(spoolPath) >= MAX_SPOOL_BYTES) return;
     appendFileSync(spoolPath, `${JSON.stringify(post2)}
 `, { mode: 384 });
   } catch {
@@ -847,7 +3239,7 @@ function append(spoolPath, post2) {
 }
 function read(spoolPath) {
   try {
-    return readFileSync5(spoolPath, "utf8").split("\n").filter((line) => line.trim().length > 0).flatMap((line) => {
+    return readFileSync6(spoolPath, "utf8").split("\n").filter((line) => line.trim().length > 0).flatMap((line) => {
       try {
         return [JSON.parse(line)];
       } catch {
@@ -876,7 +3268,7 @@ function keep(spoolPath, remaining) {
 }
 function sizeOf(path) {
   try {
-    return readFileSync5(path).byteLength;
+    return readFileSync6(path).byteLength;
   } catch {
     return 0;
   }
@@ -884,7 +3276,10 @@ function sizeOf(path) {
 
 // src/capture.ts
 var DEADLINE_MS = 6e3;
-var MAX_TRANSCRIPT_BYTES = 256 * 1024 * 1024;
+var MAX_TRANSCRIPT_BYTES2 = 256 * 1024 * 1024;
+function subagentTranscriptPath(parentTranscriptPath, sessionId, agentId) {
+  return join7(dirname3(parentTranscriptPath), sessionId, "subagents", `agent-${agentId}.jsonl`);
+}
 function readStdin() {
   return new Promise((resolve) => {
     let raw = "";
@@ -902,8 +3297,8 @@ function withDeadline(work, ms) {
 }
 function parseTranscript(path, cwd) {
   try {
-    const stat = statSync3(path);
-    if (!stat.isFile() || stat.size > MAX_TRANSCRIPT_BYTES) return null;
+    const stat = statSync5(path);
+    if (!stat.isFile() || stat.size > MAX_TRANSCRIPT_BYTES2) return null;
     return parseTranscriptFile(path, cwd, deriveRepoId(cwd));
   } catch {
     return null;
@@ -930,9 +3325,11 @@ async function deliver(spoolPath, path, body, deps) {
 }
 async function handleEvent(event, deps) {
   const name = event.hook_event_name;
+  if (!name) return null;
+  if (event.conversation_id && !event.session_id) return handleCursorEvent(event, name, deps);
   const sessionId = event.session_id;
-  if (!name || !sessionId) return null;
-  const spoolPath = join2(stateDir(deps.home), "spool.jsonl");
+  if (!sessionId) return null;
+  const spoolPath = join7(stateDir(deps.home), "spool.jsonl");
   const drained = await drainSpool(spoolPath, deps);
   const path = statePath(deps.home);
   const state = readState(path) ?? EMPTY;
@@ -948,6 +3345,13 @@ async function handleEvent(event, deps) {
   if (!transcriptPath) {
     return { event: name, turnsSent: 0, archived: false, spoolDrained: drained.sent };
   }
+  if (name === "SubagentStop" && event.agent_id) {
+    const childPath = subagentTranscriptPath(transcriptPath, sessionId, event.agent_id);
+    const child = parseTranscript(childPath, event.cwd ?? process.cwd());
+    if (child) {
+      await deliver(spoolPath, "/ingest/sessions", { sessions: [child] }, deps);
+    }
+  }
   const parsed = parseTranscript(transcriptPath, event.cwd ?? process.cwd());
   const sentThrough = prior?.sentThrough ?? 0;
   let turnsSent = 0;
@@ -979,6 +3383,39 @@ async function handleEvent(event, deps) {
   writeState(path, state);
   return { event: name, turnsSent, archived, spoolDrained: drained.sent };
 }
+var CURSOR_ENDINGS = /* @__PURE__ */ new Set(["stop", "sessionEnd"]);
+async function handleCursorEvent(event, name, deps) {
+  if (!CURSOR_ENDINGS.has(name)) return { event: name, turnsSent: 0, archived: false, spoolDrained: 0 };
+  const cwd = event.workspace_roots?.[0] ?? event.cwd ?? process.cwd();
+  const { parseCursorConversation: parseCursorConversation2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+  let parsed;
+  try {
+    parsed = parseCursorConversation2(event.conversation_id, cwd);
+  } catch {
+    return null;
+  }
+  if (!parsed) return null;
+  const spoolPath = join7(stateDir(deps.home), "spool.jsonl");
+  const drained = await drainSpool(spoolPath, deps);
+  const path = statePath(deps.home);
+  const state = readState(path) ?? EMPTY;
+  const prior = state.sessions[parsed.id];
+  const sentThrough = prior?.sentThrough ?? 0;
+  let turnsSent = 0;
+  if (parsed.turnCount > sentThrough) {
+    const ok = await deliver(spoolPath, "/ingest/sessions", { sessions: [parsed] }, deps);
+    turnsSent = ok ? parsed.turnCount - sentThrough : 0;
+  }
+  state.sessions[parsed.id] = {
+    transcriptPath: `cursor://${event.conversation_id}`,
+    sentThrough: parsed.turnCount,
+    startedAt: prior?.startedAt ?? deps.now().toISOString(),
+    // No transcript file to archive; the store is the archive.
+    archived: true
+  };
+  writeState(path, state);
+  return { event: name, turnsSent, archived: false, spoolDrained: drained.sent };
+}
 async function main() {
   const raw = await withDeadline(readStdin(), DEADLINE_MS);
   if (!raw) return;
@@ -991,7 +3428,7 @@ async function main() {
   const { evrexApi: evrexApi2 } = await Promise.resolve().then(() => (init_client(), client_exports));
   const deps = {
     now: () => /* @__PURE__ */ new Date(),
-    home: homedir2(),
+    home: homedir7(),
     machine: hostname(),
     post: async (path, body) => {
       try {
@@ -1018,5 +3455,6 @@ main().then(
 export {
   drainSpool,
   handleEvent,
-  parseTranscript
+  parseTranscript,
+  subagentTranscriptPath
 };