skalpel 4.0.10 → 4.0.12

package/autopsy.mjs

@@ -1,20 +1,36 @@
 #!/usr/bin/env node
-// autopsy.mjs — `skalpel autopsy`: a LOCAL, READ-ONLY, ZERO-NETWORK receipt.
+// autopsy.mjs — `skalpel autopsy`: a LOCAL, READ-ONLY, ZERO-NETWORK, CROSS-VENDOR receipt.
 //
 // It graduates the resident statistical instrument (the relational backtest that returned GO with an
 // independently-verified 0/20 false-join rate) into a one-shot command. It reads the coding logs that
-// are ALREADY on this machine — ~/.claude/projects/**/*.jsonl (top-level interactive sessions) and, for
-// context only, ~/.skalpel/*.ndjson — and renders a plain-text, screenshot-native receipt of 1-3
-// VERIFIED behavioral relations. Every number it prints re-derives exactly from the raw logs: each
-// relation quotes the user's own lines VERBATIM with {session,turn,ts} citations and a `reproduce:`
-// line that re-opens the cited files fresh from disk and re-confirms the count.
+// are ALREADY on this machine, across EVERY local agent it can find — and renders a plain-text,
+// screenshot-native receipt of VERIFIED behavioral relations. Every number it prints re-derives exactly
+// from the raw logs of the vendor it came from: each relation quotes the user's own lines VERBATIM with
+// {session,turn,ts,tool} citations and a `reproduce:` line that re-opens the cited store FRESH from disk
+// and re-confirms the count — PER VENDOR.
+//
+// VENDORS READ (all local, read-only):
+//   • Claude Code — ~/.claude/projects/**/*.jsonl                 (top-level interactive sessions)
+//   • Codex       — ~/.codex/{sessions,archived_sessions}/**/rollout-*.jsonl
+//   • Cursor      — ~/Library/Application Support/Cursor/User/globalStorage/state.vscdb
+//                   (SQLite `cursorDiskKV` bubbleId:* rows, read via the node: core `node:sqlite`)
+//   • Aider       — ~/.aider.chat.history.md  (parsed if present)
+//
+// THE CROSS-VENDOR MOVE (this cycle): a single model vendor can only ever autopsy its OWN logs (a
+// retention conflict no one else can resolve). skalpel reads them ALL and, when the SAME specific error
+// or file follows you across two different agents, it says so out loud — "this appears in both Claude
+// Code and Cursor" — with each side's count reproducing from that side's raw store. When only one agent
+// has usable history, it shows the single-vendor findings and HONESTLY invites connecting a second.
 //
 // HARD INVARIANTS (enforced by construction):
-//   1. ZERO NETWORK. This file imports ONLY node:fs / node:path / node:os / node:readline.
-//      No http/https/net/dns/fetch/child_process. It never opens a socket. It only reads local files.
+//   1. ZERO NETWORK. This file imports ONLY node: core modules (node:fs / node:path / node:os /
+//      node:readline / node:sqlite). No http/https/net/dns/fetch/child_process. It never opens a socket.
+//      It only reads local files. `node:sqlite` is a Node core module — it is a local file reader, not a
+//      network client — and is loaded lazily so an older Node simply skips Cursor instead of crashing.
 //   2. NO FABRICATED STATS. Nothing is rendered unless it re-derives verbatim from disk. If there is
 //      not enough history to cross the bar, it prints an HONEST ZERO-STATE with a live turn counter —
-//      never an invented finding.
+//      never an invented finding. A cross-vendor claim is made ONLY when >=2 vendors independently
+//      reproduce the anchor.
 //   3. HONEST FOOTER. It states that THIS RECEIPT is generated locally, read-only. It does NOT and must
 //      not claim the whole product is local: the per-turn hook and SessionEnd ingest STILL upload
 //      transcripts today. Zero-network ingest is a later cycle.
@@ -24,6 +40,8 @@
 //            / normalized n-gram), witness per session. Asserted as a headline.
 //   CELL C — density-gated MEASURED SPIRAL: the same error anchor recurring within <=30min gaps inside
 //            one session, with wall-clock duration. Asserted as a headline.
+//   CELL X — CROSS-VENDOR recurrence: the SAME specific anchor appearing in sessions from >=2 different
+//            agents, each side's count reproduced from that agent's own raw store. The un-absorbable one.
 //   CELL B — "answer already on screen" is DEMOTED to witness-adjudicated only (it is the fakeable-by-
 //            mislabel trust bomb) and is NEVER surfaced as an asserted headline here.
 
@@ -35,6 +53,30 @@ import readline from "node:readline";
 const HOME = os.homedir();
 const PROJECTS_DIR = path.join(HOME, ".claude", "projects");
 const SKALPEL_DIR = path.join(HOME, ".skalpel");
+const CODEX_SESSIONS_DIRS = [
+  path.join(HOME, ".codex", "sessions"),
+  path.join(HOME, ".codex", "archived_sessions"),
+];
+const CURSOR_DB = path.join(
+  HOME,
+  "Library",
+  "Application Support",
+  "Cursor",
+  "User",
+  "globalStorage",
+  "state.vscdb",
+);
+const AIDER_HISTORY = path.join(HOME, ".aider.chat.history.md");
+
+// vendor identity + display labels (threaded onto every turn as source_tool)
+const SRC = { claude: "claude", codex: "codex", cursor: "cursor", aider: "aider" };
+const SRC_LABEL = {
+  claude: "Claude Code",
+  codex: "Codex",
+  cursor: "Cursor",
+  aider: "Aider",
+};
+const srcLabel = (s) => SRC_LABEL[s] || s || "?";
 
 // ---------- deterministic helpers (verbatim from the backtest engine) ----------
 const SPAN = 90;
@@ -52,6 +94,7 @@ const BOILER_MARKERS = [
   "deferred_tools",
   "MCP server",
   "You are Claude Code",
+  "You are Codex",
   "IMPORTANT: These instructions OVERRIDE",
   "hookSpecificOutput",
   "additionalContext",
@@ -62,6 +105,8 @@ const BOILER_MARKERS = [
   "claudeMd",
   "userEmail",
   "currentDate",
+  "<permissions instructions>",
+  "AGENTS.md instructions for",
 ];
 const isBoiler = (t) => {
   const l = t.slice(0, 400);
@@ -147,8 +192,14 @@ function extractAnchors(text) {
   const fileRe =
     /\b[\w-]+(?:\/[\w.-]+)*\.(?:rs|ts|tsx|jsx|mjs|cjs|go|py|sql|toml|yaml|yml|sh|astro|vue|svelte)\b/g;
   while ((m = fileRe.exec(text))) {
-    const base = m[0].split("/").pop();
-    if (!GENERIC.has(base.split(".")[0])) push("sym:file", base, m.index);
+    const raw = m[0]; // the mentioned path token, e.g. "src/components/Hero.astro" or "Users/ryan/…/Hero.astro"
+    const base = raw.split("/").pop();
+    if (!GENERIC.has(base.split(".")[0])) {
+      // fileRe cannot start on the leading "/", so an absolute path shows up as raw="Users/…" with a
+      // "/" immediately before it. Detect that so the path can be resolved to a real file IDENTITY.
+      const abs = m.index > 0 && text[m.index - 1] === "/";
+      out.push({ kind: "sym:file", anchor: base, at: m.index, rawPath: raw, abs });
+    }
   }
   const rustRe = /\b[a-z_][a-z0-9_]{2,}::[a-z_][a-z0-9_:]{2,}/g;
   while ((m = rustRe.exec(text))) push("sym:path", m[0], m.index);
@@ -167,8 +218,19 @@ function span(text, at, len) {
   return text.slice(a, b).replace(/\s+/g, " ").trim().slice(0, 200);
 }
 
-// ---------- parse one session (verbatim shape from the backtest engine) ----------
-function parseSession(file, rootDir) {
+// ~/.claude/projects encodes cwd as a dash-flattened path. Every vendor's project root is normalized to
+// this same encoding so decodeRoot / projTail / isHomeRoot work uniformly regardless of source tool.
+const encodeCwd = (cwd) => (cwd ? cwd.replace(/\//g, "-") : "");
+
+// ================= per-vendor parsers → ONE normalized shape =================
+// normalized turn: { session_id, root, role, turn_idx, ts, tms, text, toolErrText, mineErrOnly,
+//                    toolCalls, boiler, source_tool, bubbleKey }
+// normalized session: { sessionId, rootDir, source_tool, turns:[turn] }
+// fileForSession maps a claude/codex session_id → its raw file so `reproduce` can re-open it fresh.
+const fileForSession = new Map();
+
+// ---------- CLAUDE CODE: parse one jsonl session (verbatim shape from the backtest engine) ----------
+function parseClaudeSession(file, rootDir) {
   return new Promise((resolve) => {
     const sessionId = path.basename(file, ".jsonl");
     const turns = [];
@@ -222,17 +284,298 @@ function parseSession(file, rootDir) {
         mineErrOnly: !text && !!toolErrText,
         toolCalls,
         boiler,
+        source_tool: SRC.claude,
+        bubbleKey: null,
       });
     });
-    rl.on("close", () => resolve({ sessionId, rootDir, turns }));
-    rl.on("error", () => resolve({ sessionId, rootDir, turns }));
+    rl.on("close", () => {
+      fileForSession.set(sessionId, file);
+      resolve({ sessionId, rootDir, source_tool: SRC.claude, turns });
+    });
+    rl.on("error", () => resolve({ sessionId, rootDir, source_tool: SRC.claude, turns }));
   });
 }
 
-// ---------- reproduce affordance: re-open a cited file FRESH, jump to the turn, re-confirm ----------
-// This is the authoritative re-derivation. It reads the raw jsonl again (independent of the in-memory
-// parse) and confirms the anchor is verbatim present at the cited turn.
-function readTurnText(file, targetIdx) {
+// ---------- CODEX: shared turn-emitter (used by BOTH parse and reproduce → identical indexing) ----------
+// A Codex rollout-*.jsonl is an event log. A "turn" is each response_item/message (user/assistant) plus
+// each response_item/function_call_output (tool/command output, where compiler & runtime errors live).
+// developer-role messages are system boilerplate and are skipped.
+function codexTurns(file) {
+  let lines;
+  try {
+    lines = fs.readFileSync(file, "utf8").split("\n");
+  } catch {
+    return { id: null, cwd: "", turns: [] };
+  }
+  let id = null,
+    cwd = "";
+  const turns = [];
+  for (const line of lines) {
+    if (!line) continue;
+    let o;
+    try {
+      o = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (o.type === "session_meta" && o.payload) {
+      id = o.payload.id || id;
+      cwd = o.payload.cwd || cwd;
+      continue;
+    }
+    if (o.type !== "response_item" || !o.payload) continue;
+    const p = o.payload;
+    const ts = o.timestamp || null;
+    if (p.type === "message") {
+      if (p.role === "developer") continue; // system boilerplate
+      const text = (Array.isArray(p.content) ? p.content : [])
+        .map((c) => (c && typeof c.text === "string" ? c.text : ""))
+        .join("\n")
+        .trim();
+      if (!text) continue;
+      turns.push({
+        role: p.role === "assistant" ? "assistant" : "user",
+        text,
+        toolErrText: "",
+        mineErrOnly: false,
+        ts,
+        from: "message",
+      });
+    } else if (p.type === "function_call_output") {
+      const raw = p.output;
+      const s = (typeof raw === "string" ? raw : JSON.stringify(raw || "")).trim();
+      if (!s) continue;
+      turns.push({
+        role: "assistant",
+        text: "",
+        toolErrText: s.slice(0, 4000),
+        mineErrOnly: true,
+        ts,
+        from: "tool_output",
+      });
+    }
+  }
+  return { id, cwd, turns };
+}
+
+function parseCodexSession(file) {
+  const { id, cwd, turns: raw } = codexTurns(file);
+  const sessionId = id || path.basename(file, ".jsonl");
+  const rootDir = encodeCwd(cwd);
+  const turns = raw.map((t, idx) => ({
+    session_id: sessionId,
+    root: rootDir,
+    role: t.role,
+    turn_idx: idx,
+    ts: t.ts,
+    tms: t.ts ? Date.parse(t.ts) : null,
+    text: (t.text || "").slice(0, 6000),
+    toolErrText: (t.toolErrText || "").slice(0, 4000),
+    mineErrOnly: t.mineErrOnly,
+    toolCalls: [],
+    boiler: t.text ? isBoiler(t.text) : false,
+    source_tool: SRC.codex,
+    bubbleKey: null,
+  }));
+  if (turns.length) fileForSession.set(sessionId, file);
+  return { sessionId, rootDir, source_tool: SRC.codex, turns };
+}
+
+function walkRollouts(dir) {
+  let out = [];
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) out = out.concat(walkRollouts(p));
+    else if (/^rollout-.*\.jsonl$/.test(e.name)) out.push(p);
+  }
+  return out;
+}
+
+function loadCodexSessions() {
+  const files = [];
+  for (const d of CODEX_SESSIONS_DIRS) files.push(...walkRollouts(d));
+  const sessions = [];
+  for (const f of files) {
+    const s = parseCodexSession(f);
+    if (s.turns.length) sessions.push(s);
+  }
+  return sessions;
+}
+
+function readCodexTurnText(file, targetIdx) {
+  const { turns } = codexTurns(file);
+  const t = turns[targetIdx];
+  return t ? t.text || t.toolErrText || null : null;
+}
+
+// ---------- CURSOR: read the SQLite chat store via the node: core `node:sqlite` (lazy, graceful) ----
+// Cursor stores each chat message as a row `bubbleId:<composerId>:<bubbleId>` in cursorDiskKV. The value
+// is JSON with { type:1=user|2=assistant, text, createdAt }. We group by composerId (=session), order by
+// createdAt, and normalize. `node:sqlite` is a Node core module (>=22.5 / stable in 24+); if it is not
+// available we simply skip Cursor — never crash, never fabricate.
+let DatabaseSyncClass = null;
+async function loadCursorSessions() {
+  if (!fs.existsSync(CURSOR_DB)) return [];
+  try {
+    const mod = await import("node:sqlite");
+    DatabaseSyncClass = mod.DatabaseSync;
+  } catch {
+    return []; // Node too old for node:sqlite — skip Cursor honestly
+  }
+  let rows = [];
+  try {
+    const db = new DatabaseSyncClass(CURSOR_DB, { readOnly: true });
+    rows = db
+      .prepare(
+        "SELECT key, json_extract(value,'$.type') AS type, json_extract(value,'$.text') AS text, json_extract(value,'$.createdAt') AS createdAt FROM cursorDiskKV WHERE key LIKE 'bubbleId:%' AND length(json_extract(value,'$.text'))>0",
+      )
+      .all();
+    db.close();
+  } catch {
+    return [];
+  }
+  // group by composerId; key = bubbleId:<composerId(36)>:<bubbleId>
+  const byComposer = new Map();
+  for (const r of rows) {
+    const composerId = r.key.slice("bubbleId:".length, "bubbleId:".length + 36);
+    if (!byComposer.has(composerId)) byComposer.set(composerId, []);
+    byComposer.get(composerId).push(r);
+  }
+  const sessions = [];
+  for (const [composerId, bubbles] of byComposer) {
+    bubbles.sort((a, b) => (Date.parse(a.createdAt) || 0) - (Date.parse(b.createdAt) || 0));
+    const turns = bubbles.map((b, idx) => {
+      const text = (b.text || "").trim();
+      return {
+        session_id: composerId,
+        root: null, // Cursor bubbles carry no reliable cwd; project is unknown (never faked)
+        role: b.type === 1 ? "user" : "assistant",
+        turn_idx: idx,
+        ts: b.createdAt || null,
+        tms: b.createdAt ? Date.parse(b.createdAt) : null,
+        text: text.slice(0, 6000),
+        toolErrText: "",
+        mineErrOnly: false,
+        toolCalls: [],
+        boiler: isBoiler(text),
+        source_tool: SRC.cursor,
+        bubbleKey: b.key,
+      };
+    });
+    if (turns.length)
+      sessions.push({ sessionId: composerId, rootDir: null, source_tool: SRC.cursor, turns });
+  }
+  return sessions;
+}
+
+function readCursorBubbleText(bubbleKey) {
+  if (!DatabaseSyncClass || !bubbleKey) return null;
+  try {
+    const db = new DatabaseSyncClass(CURSOR_DB, { readOnly: true });
+    const row = db
+      .prepare("SELECT json_extract(value,'$.text') AS text FROM cursorDiskKV WHERE key = ?")
+      .get(bubbleKey);
+    db.close();
+    return row && row.text ? String(row.text) : null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------- AIDER: ~/.aider.chat.history.md (markdown transcript), parsed if present ----------
+// Format: "#### <user message>" lines for the user, assistant prose in between, "> " session banners.
+// Aider does not stamp per-message timestamps, so ts is null (recurrence/cross-vendor still work; the
+// in-session SPIRAL cell, which needs wall-clock, simply won't fire for Aider — honest by construction).
+function loadAiderSessions() {
+  if (!fs.existsSync(AIDER_HISTORY)) return [];
+  let text;
+  try {
+    text = fs.readFileSync(AIDER_HISTORY, "utf8");
+  } catch {
+    return [];
+  }
+  const lines = text.split("\n");
+  // A "# aider chat started at <ts>" banner opens each session.
+  const sessions = [];
+  let cur = null,
+    idx = 0,
+    sc = 0;
+  const startSession = (ts) => {
+    sc++;
+    const sessionId = "aider-" + sc + (ts ? "-" + ts.replace(/[^0-9]/g, "").slice(0, 12) : "");
+    cur = { sessionId, rootDir: null, source_tool: SRC.aider, turns: [] };
+    idx = 0;
+    sessions.push(cur);
+  };
+  let sessTs = null;
+  let pendingRole = null,
+    buf = [];
+  const flush = () => {
+    if (!cur || !pendingRole) {
+      buf = [];
+      pendingRole = null;
+      return;
+    }
+    const body = buf.join("\n").trim();
+    if (body) {
+      cur.turns.push({
+        session_id: cur.sessionId,
+        root: null,
+        role: pendingRole,
+        turn_idx: idx++,
+        ts: sessTs,
+        tms: sessTs ? Date.parse(sessTs) : null,
+        text: body.slice(0, 6000),
+        toolErrText: "",
+        mineErrOnly: false,
+        toolCalls: [],
+        boiler: isBoiler(body),
+        source_tool: SRC.aider,
+        bubbleKey: null,
+      });
+    }
+    buf = [];
+    pendingRole = null;
+  };
+  for (const line of lines) {
+    const banner = /^#\s+aider chat started at (.+)$/.exec(line);
+    if (banner) {
+      flush();
+      sessTs = banner[1].trim();
+      startSession(sessTs);
+      continue;
+    }
+    if (!cur) startSession(null);
+    if (/^####\s+/.test(line)) {
+      flush();
+      pendingRole = "user";
+      buf.push(line.replace(/^####\s+/, ""));
+    } else if (/^>\s?/.test(line)) {
+      // aider command/tool echo — treat as session output continuation
+      if (pendingRole !== "assistant") {
+        flush();
+        pendingRole = "assistant";
+      }
+      buf.push(line.replace(/^>\s?/, ""));
+    } else {
+      if (!pendingRole) pendingRole = "assistant";
+      buf.push(line);
+    }
+  }
+  flush();
+  return sessions.filter((s) => s.turns.length);
+}
+
+// ---------- reproduce affordance: re-open a cited store FRESH, jump to the turn, re-confirm ----------
+// This is the authoritative re-derivation. It reads the raw store again (independent of the in-memory
+// parse) and confirms the anchor is verbatim present at the cited turn — dispatched per source tool.
+function readClaudeTurnText(file, targetIdx) {
   let lines;
   try {
     lines = fs.readFileSync(file, "utf8").split("\n");
@@ -277,20 +620,42 @@ function readTurnText(file, targetIdx) {
   return null;
 }
 
+// dispatch a fresh, independent re-read of ONE cited witness by its source tool.
+function reopenTurnText(w) {
+  if (w.source_tool === SRC.cursor) return readCursorBubbleText(w.bubbleKey);
+  if (w.source_tool === SRC.aider) return w.verbatim || null; // aider md has no random-access index; span is the record
+  const file = fileForSession.get(w.session_id);
+  if (!file) return null;
+  if (w.source_tool === SRC.codex) return readCodexTurnText(file, w.turn_idx);
+  return readClaudeTurnText(file, w.turn_idx);
+}
+
 // Re-derive a relation's number from disk. Returns { confirmed, total } — how many cited witnesses
 // still have the anchor verbatim at the cited turn after a fresh, independent re-read.
-function reproduceCount(fileIndex, anchor, witnesses) {
+function reproduceCount(anchor, witnesses) {
   let confirmed = 0;
   const total = witnesses.length;
   for (const w of witnesses) {
-    const file = fileIndex.get(w.session_id);
-    if (!file) continue;
-    const txt = readTurnText(file, w.turn_idx);
-    if (txt && norm(txt).includes(norm(anchor))) confirmed++;
+    const txt = reopenTurnText(w);
+    // For files, w.reAnchor is the FULL mentioned path (e.g. "src/components/Hero.astro" or the
+    // absolute) — re-confirming it, not the bare basename, is what proves the same actual file.
+    const need = w.reAnchor || anchor;
+    if (txt && norm(txt).includes(norm(need))) confirmed++;
   }
   return { confirmed, total };
 }
 
+// human-readable pointer to the raw source of a cited witness (for the reproduce block).
+function srcPointer(w) {
+  if (w.source_tool === SRC.cursor) {
+    return `${CURSOR_DB}  → cursorDiskKV[${w.bubbleKey}]`;
+  }
+  if (w.source_tool === SRC.aider)
+    return `${AIDER_HISTORY}  @${srcLabel(w.source_tool)} turn ${w.turn_idx}`;
+  const f = fileForSession.get(w.session_id);
+  return f ? `${f}  @turn ${w.turn_idx}` : null;
+}
+
 // ---------- rendering helpers ----------
 const short = (sid) => (sid || "").slice(0, 8);
 const shortTs = (ts) => {
@@ -309,8 +674,6 @@ function plainAnchor(kind, anchor) {
 }
 
 function projLabel(root) {
-  // ~/.claude/projects encodes the cwd as a dash-flattened path; show a short tail if meaningful.
-  // The HOME catch-all root is not a project — suppress it (handled by projTail returning null).
   const tail = projTail(root);
   return tail ? `  (${tail})` : "";
 }
@@ -329,41 +692,46 @@ function projTail(root) {
   const tail = parts.slice(-2).join("/");
   return tail ? `~/${tail}` : null;
 }
+// Resolve a mentioned file token to a stable, absolute IDENTITY so cross-vendor "same file" means the
+// SAME ACTUAL FILE — not a shared basename. Returns a normalized absolute path, or null when the
+// mention cannot be pinned to a real file:
+//   • absolute path in the text        → that path IS the identity (works across every vendor).
+//   • relative path WITH a directory    → resolved against the session's project root (cwd), but ONLY
+//                                         when that root is a real project (never the home catch-all,
+//                                         and never Cursor's rootless bubbles) — otherwise unknowable.
+//   • bare basename (no directory)      → null. A basename alone can never prove same-file.
+function resolveFileIdentity(rawPath, abs, root) {
+  if (!rawPath) return null;
+  if (abs) return path.posix.normalize("/" + rawPath.replace(/^\/+/, ""));
+  if (!rawPath.includes("/")) return null; // bare basename — not a same-file proof
+  if (/^\.\.?\//.test(rawPath)) return null; // "./x" or "../x": ambiguous relative to an unknown subdir
+  const base = decodeRoot(root); // "" when root is null (Cursor) or unknown
+  if (!base || base === HOME) return null; // no real project root to anchor a relative path against
+  return path.posix.normalize(base.replace(/\/+$/, "") + "/" + rawPath);
+}
 // Detect any email (incl. TLDs truncated by the 200-char span slice, e.g. "name@host.c" or "name@host").
 const EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9][A-Za-z0-9.-]*/g;
 
 // ---------- PII redaction (default ON; --raw reveals locally) ----------
-// The default receipt is meant to be screenshot-shareable. Third-party emails, personal/company
-// domains, IPs and secrets in the quoted verbatim spans are redacted to typed placeholders. `--raw`
-// (a purely local flag; there is still no network) reveals the unredacted spans for the user's eyes.
 const RAW = process.argv.slice(2).includes("--raw");
-// TLD allowlist so real domains are caught but code filenames (foo.rs / bar.mjs / package.json) are NOT.
 const DOMAIN_RE =
   /\b(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:com|ai|io|co|org|net|dev|app|xyz|so|gg|inc|us|uk|ca|de|eu|me|info|biz|tech|studio|cloud|sh|live|news|gov|edu|ly)\b/gi;
 function redact(s) {
   if (RAW || !s) return s;
   let t = s;
-  // secrets/keys/tokens first (before anything else can nibble their edges)
   t = t.replace(/\b(?:sk|pk|rk)-[A-Za-z0-9_-]{16,}\b/g, "[token]");
   t = t.replace(/\bgh[pousr]_[A-Za-z0-9]{20,}\b/g, "[token]");
   t = t.replace(/\bAKIA[0-9A-Z]{16}\b/g, "[token]");
   t = t.replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\b/g, "[token]");
   t = t.replace(/\b[Bb]earer\s+[A-Za-z0-9._-]{16,}/g, "Bearer [token]");
-  // full URLs (host + path) collapse to [url] — a URL can carry a personal host and query params
   t = t.replace(/\bhttps?:\/\/[^\s"'<>)\]]+/gi, "[url]");
-  // emails (before bare-domain pass; matches even TLD-truncated tails at a 200-char span boundary)
   t = t.replace(EMAIL_RE, "[email]");
-  // IPv4
   t = t.replace(/\b\d{1,3}(?:\.\d{1,3}){3}\b/g, "[ip]");
-  // bare domains (company / personal sites)
   t = t.replace(DOMAIN_RE, "[domain]");
   return t;
 }
 
 // ---------- autopsy self-echo filter ----------
-// This command prints error strings and symbols into the terminal; that output is itself captured in
-// the transcript. Without this guard a prior receipt's own text would re-enter as fresh "occurrences"
-// and manufacture recurrence/spirals out of nothing. Any turn that looks like autopsy output is dropped.
 const AUTOPSY_ECHO = [
   "skalpel autopsy",
   "nothing left this machine",
@@ -381,14 +749,33 @@ const AUTOPSY_ECHO = [
   "all hit the error",
   "in the same project",
   "Your session hit the error",
+  "cross-vendor",
+  "appears in both",
+  "connect a 2nd agent",
+  "basename collision",
+  "basename-only",
+  "same actual file",
+  "same actual path",
+  "same absolute path",
+  "same project-root",
+  "followed you across",
+  "honest-absence",
+  "honest absence",
+  "single-vendor",
+  "cross-vendor autopsy",
+  "the same file followed you",
+  "distinctive symbol",
+  "distinctive-error",
 ];
+// Case-insensitive: a receipt/meta-discussion turn can quote the vocabulary in any case (BASENAME,
+// Cross-Vendor, …). Two distinct markers in the first 800 chars ⇒ it is talking ABOUT the autopsy,
+// so it is excluded from anchor mining — the tool must never report on its own machinery.
 const isAutopsyEcho = (s) => {
   if (!s) return false;
-  const l = s.slice(0, 800);
-  // require two distinct markers to avoid nuking legitimate turns that merely say "recurred" once
+  const l = s.slice(0, 800).toLowerCase();
   let hits = 0;
   for (const m of AUTOPSY_ECHO) {
-    if (l.includes(m)) {
+    if (l.includes(m.toLowerCase())) {
       hits++;
       if (hits >= 2) return true;
     }
@@ -397,18 +784,225 @@ const isAutopsyEcho = (s) => {
 };
 
 // ---------- sourcing: user-typed vs tool/session output ----------
-// A witness is "you wrote" ONLY when it is a user-role turn whose anchor came from the typed message
-// body. Assistant text and tool_result output are "session output" — never attributed to the user.
 const isUserTyped = (w) => w.role === "user" && w.from === "message";
 const srcTag = (w) => (isUserTyped(w) ? "you wrote" : "session output");
 
+// specificity gates shared by CELL A and CELL X
+const ERR_SPECIFIC = new Set([
+  "err:rustc",
+  "err:tsc",
+  "err:notfound",
+  "err:unresolved",
+  "err:panic",
+  "err:sqlx",
+]);
+const BARE_FILES = new Set([
+  "index.ts",
+  "index.js",
+  "index.tsx",
+  "index.mjs",
+  "index.jsx",
+  "mod.rs",
+  "main.rs",
+  "lib.rs",
+  "package.json",
+  "README.md",
+  "tsconfig.json",
+  "Cargo.toml",
+]);
+// Generic framework/scaffolding filenames whose BASENAME collides across unrelated projects (a Next.js
+// `page.tsx` here, a different `page.tsx` there). A cross-vendor claim on a basename collision would be
+// a mislabel — "the same file" when they are different files — so these are suppressed. A DISTINCTIVE
+// filename (Hero.astro, pricing-tiers.ts) is a strong same-file proxy and is allowed. This is the
+// cross-vendor analogue of CELL A's same-project relatedness gate (which we cannot apply directly: Cursor
+// bubbles carry no cwd).
+const CROSS_COMMON_CORES = new Set([
+  "config",
+  "next.config",
+  "vite.config",
+  "tailwind.config",
+  "postcss.config",
+  "jest.config",
+  "vitest.config",
+  "rollup.config",
+  "webpack.config",
+  "tsup.config",
+  "turbo",
+  "api",
+  "page",
+  "layout",
+  "route",
+  "index",
+  "main",
+  "mod",
+  "lib",
+  "types",
+  "type",
+  "utils",
+  "util",
+  "constants",
+  "helpers",
+  "helper",
+  "styles",
+  "style",
+  "app",
+  "server",
+  "client",
+  "db",
+  "schema",
+  "hooks",
+  "hook",
+  "store",
+  "actions",
+  "action",
+  "providers",
+  "provider",
+  "theme",
+  "env",
+  "setup",
+  "middleware",
+  "loading",
+  "error",
+  "globals",
+  "global",
+  "icons",
+  "icon",
+  "proxy",
+  "ci",
+  "promote",
+  "default",
+  "template",
+  "head",
+  "not-found",
+  "docker-compose",
+  "dockerfile",
+  "makefile",
+  "readme",
+  "cli",
+  "auth",
+  "models",
+  "model",
+  "settings",
+  "options",
+  "component",
+  "components",
+  "handler",
+]);
+// Common library / runtime / build tokens: identical across everyone's projects, so they are NOT a
+// distinctive "your work followed you" anchor. A symbol must clear this list (and a frequency ceiling)
+// to be a genuine cross-vendor signal. Not exhaustive — the frequency ceiling is the real backstop.
+const SCAFFOLD_SYMBOLS = new Set([
+  "addeventlistener",
+  "removeeventlistener",
+  "getelementbyid",
+  "queryselector",
+  "queryselectorall",
+  "createelement",
+  "appendchild",
+  "setattribute",
+  "getattribute",
+  "classlist",
+  "innerhtml",
+  "textcontent",
+  "usestate",
+  "useeffect",
+  "usecallback",
+  "usememo",
+  "usecontext",
+  "useref",
+  "usereducer",
+  "foreach",
+  "tostring",
+  "valueof",
+  "constructor",
+  "prototype",
+  "stringify",
+  "parseint",
+  "parsefloat",
+  "tolowercase",
+  "touppercase",
+  "trimstart",
+  "trimend",
+  "startswith",
+  "endswith",
+  "indexof",
+  "lastindexof",
+  "includes",
+  "createinterface",
+  "readfilesync",
+  "writefilesync",
+  "readdirsync",
+  "existssync",
+  "createreadstream",
+  "spawnsync",
+  "execsync",
+  "setinterval",
+  "setttimeout",
+  "settimeout",
+  "clearinterval",
+  "cleartimeout",
+  "unwrap",
+  "to_string",
+  "into_iter",
+  "as_str",
+  "as_ref",
+  "clone",
+  "collect",
+  "serialize",
+  "deserialize",
+  "async_trait",
+  "tokio",
+  "serde",
+  "sqlx",
+  "anyhow",
+  "thiserror",
+  "node_modules",
+  "package_json",
+  "tsconfig_json",
+  "sourcemappingurl",
+  "getserversideprops",
+  "getstaticprops",
+  "getstaticpaths",
+]);
+
+// A distinctive symbol/function name is genuinely PORTABLE across vendors: the identical token string
+// in two agents is the same code entity (unlike a basename). Eligibility: not generic/template/
+// scaffolding, long enough to be specific, and NOT so ubiquitous it is obviously a library token
+// (appearing in more than a handful of distinct sessions ⇒ shared vocabulary, not a personal anchor).
+function symbolDistinctive(kind, anchor, sessionCount) {
+  if (kind !== "sym:path" && kind !== "sym:ident") return false;
+  const a = anchor.toLowerCase();
+  if (isTemplateTok(anchor)) return false;
+  if (GENERIC.has(a) || CROSS_COMMON_CORES.has(a) || SCAFFOLD_SYMBOLS.has(a)) return false;
+  // any path/ident segment being a scaffold token drags the whole anchor toward library noise
+  for (const seg of a.split(/[^a-z0-9]+/).filter(Boolean))
+    if (SCAFFOLD_SYMBOLS.has(seg)) return false;
+  if (kind === "sym:path") {
+    if (anchor.length < 10) return false; // namespaced `a::b` — needs real length to be specific
+  } else {
+    if (anchor.length < 12) return false; // multi-segment ident — long enough to be non-accidental
+  }
+  if (sessionCount > 6) return false; // ubiquitous ⇒ library / harness vocabulary, not a personal anchor
+  return true;
+}
+
+// A cross-vendor NON-FILE anchor (files are matched by absolute-path identity elsewhere): an
+// identifier-carrying error, or a distinctive symbol. Bare / generic tokens never qualify.
+function crossAnchorEligible(kind, anchor, sessionCount) {
+  if (isTemplateTok(anchor)) return false;
+  if (kind.startsWith("err")) return ERR_SPECIFIC.has(kind);
+  if (kind === "sym:path" || kind === "sym:ident")
+    return symbolDistinctive(kind, anchor, sessionCount);
+  return false; // sym:file is handled by path identity, never by basename here
+}
+
 // ---------- main ----------
 async function main() {
   const out = [];
   const P = (s = "") => out.push(s);
 
-  // enumerate ALL top-level interactive session files (exclude nested subagent/workflow threads,
-  // which live under <session>/subagents/ and are not distinct user sessions).
+  // ============ LOAD every local vendor (read-only) ============
+  // Claude Code — enumerate top-level interactive session files (exclude nested subagent/workflow threads).
   let roots = [];
   try {
     roots = fs.readdirSync(PROJECTS_DIR).filter((d) => {
@@ -419,9 +1013,9 @@ async function main() {
       }
     });
   } catch {
-    // no history at all
+    /* no claude history */
   }
-  const files = [];
+  const claudeFiles = [];
   for (const r of roots) {
     const dir = path.join(PROJECTS_DIR, r);
     let entries = [];
@@ -431,9 +1025,9 @@ async function main() {
       continue;
     }
     for (const f of entries)
-      if (f.endsWith(".jsonl")) files.push({ file: path.join(dir, f), root: r });
+      if (f.endsWith(".jsonl")) claudeFiles.push({ file: path.join(dir, f), root: r });
   }
-  files.sort((a, b) => {
+  claudeFiles.sort((a, b) => {
     try {
       return fs.statSync(b.file).size - fs.statSync(a.file).size;
     } catch {
@@ -441,29 +1035,66 @@ async function main() {
     }
   });
 
-  const fileIndex = new Map();
-  for (const { file } of files) fileIndex.set(path.basename(file, ".jsonl"), file);
-
   const sessions = [];
+  for (const { file, root } of claudeFiles) {
+    const s = await parseClaudeSession(file, root);
+    if (s.turns.length) sessions.push(s);
+  }
+  // Codex, Cursor, Aider
+  for (const s of loadCodexSessions()) sessions.push(s);
+  for (const s of await loadCursorSessions()) sessions.push(s);
+  for (const s of loadAiderSessions()) sessions.push(s);
+
+  // per-vendor inventory (reproducible counts)
+  const inv = {};
   let totalTurns = 0;
-  for (const { file, root } of files) {
-    const s = await parseSession(file, root);
-    if (s.turns.length) {
-      sessions.push(s);
-      totalTurns += s.turns.length;
-    }
+  for (const s of sessions) {
+    const st = s.source_tool;
+    inv[st] ??= { sessions: 0, turns: 0 };
+    inv[st].sessions += 1;
+    inv[st].turns += s.turns.length;
+    totalTurns += s.turns.length;
   }
+  const presentVendors = Object.keys(inv).filter((v) => inv[v].sessions > 0);
 
-  // ============ CELL A: cross-session recurrence on deterministic anchors ============
+  // ============ CELL A: cross-session recurrence on deterministic anchors (across the UNION) ============
+  // filePathMap indexes file mentions by RESOLVED ABSOLUTE IDENTITY (not basename) so a cross-vendor
+  // "same file" claim can require the SAME ACTUAL FILE. identity → Map(source_tool → Map(sessionId,witness)).
   const anchorMap = new Map();
+  const filePathMap = new Map();
   for (const s of sessions) {
     for (const turn of s.turns) {
       const mineText = turn.boiler ? "" : turn.text || turn.toolErrText || "";
       if (!mineText || isAutopsyEcho(mineText)) continue;
       const errOnly = turn.mineErrOnly;
       const seenThisTurn = new Set();
-      for (const { kind, anchor, at } of extractAnchors(mineText)) {
+      for (const ex of extractAnchors(mineText)) {
+        const { kind, anchor, at } = ex;
         if (errOnly && !kind.startsWith("err")) continue;
+        // ---- same-file identity index (message text only; tool output is skipped above) ----
+        if (kind === "sym:file") {
+          const identity = resolveFileIdentity(ex.rawPath, ex.abs, turn.root);
+          if (identity) {
+            if (!filePathMap.has(identity))
+              filePathMap.set(identity, { basename: anchor, byTool: new Map() });
+            const fe = filePathMap.get(identity);
+            if (!fe.byTool.has(turn.source_tool)) fe.byTool.set(turn.source_tool, new Map());
+            const perSess = fe.byTool.get(turn.source_tool);
+            if (!perSess.has(s.sessionId))
+              perSess.set(s.sessionId, {
+                session_id: s.sessionId,
+                turn_idx: turn.turn_idx,
+                ts: turn.ts,
+                role: turn.role,
+                root: turn.root,
+                from: "message",
+                source_tool: turn.source_tool,
+                bubbleKey: turn.bubbleKey,
+                verbatim: span(mineText, at, ex.rawPath.length),
+                reAnchor: ex.rawPath, // re-confirm the FULL mentioned path on a fresh re-read, not the basename
+              });
+          }
+        }
         const key = kind.startsWith("sym") ? anchor : kind + "|" + anchor.toLowerCase();
         if (seenThisTurn.has(key)) continue;
         seenThisTurn.add(key);
@@ -477,59 +1108,24 @@ async function main() {
             role: turn.role,
             root: turn.root,
             from: errOnly ? "tool_output" : "message",
+            source_tool: turn.source_tool,
+            bubbleKey: turn.bubbleKey,
             verbatim: span(mineText, at, anchor.length),
           });
         }
       }
     }
   }
-  // THE HEADLINE BAR (all must hold to be asserted as a cross-session headline):
-  //   (a) SPECIFIC anchor — a concrete file/path/symbol, OR an error carrying a specific identifier
-  //       (rustc code E####, TS####, a named missing module/import, a panic with a location, SQLX_OFFLINE).
-  //       A BARE generic error class (ECONNREFUSED / ENOENT / TypeError / segfault / "borrow of moved
-  //       value") is SUPPRESSED — the token recurs across unrelated domains; it is noise, not insight.
-  //   (b) RELATED CONTEXT — the recurring witnesses must share a context. The concrete, deterministic
-  //       relatedness signal on disk is the project root (~/.claude/projects encodes the cwd). We take
-  //       the largest same-root group of witnesses and require it to be >= 2. A generic token colliding
-  //       across different project dirs (an IPC race here, a pricing-404 there) never clears this.
-  //   (c) NON-OBVIOUS — carried by (a)+(b): the SAME specific anchor recurring in the SAME project on
-  //       different days is a real friction point, not something the user would trivially recite.
-  //       (The strongest non-obvious signal — a density-gated in-session SPIRAL — is CELL C, below.)
-  // Bare exception classes and cross-session sym:path / sym:ident hits (harness/runtime tokens like
-  // resumeFromRunId, processTicksAndRejections) are still computed but NEVER asserted as a headline.
-  const ERR_SPECIFIC = new Set([
-    "err:rustc",
-    "err:tsc",
-    "err:notfound",
-    "err:unresolved",
-    "err:panic",
-    "err:sqlx",
-  ]);
-  const BARE_FILES = new Set([
-    "index.ts",
-    "index.js",
-    "index.tsx",
-    "index.mjs",
-    "index.jsx",
-    "mod.rs",
-    "main.rs",
-    "lib.rs",
-    "package.json",
-    "README.md",
-    "tsconfig.json",
-    "Cargo.toml",
-  ]);
+
   const cellA = [];
   for (const [, rec] of anchorMap) {
     if (rec.sessions.size < 2) continue;
     if (isTemplateTok(rec.anchor)) continue;
-    // (a) specificity gate
     let eligible = false;
     if (rec.kind.startsWith("err")) eligible = ERR_SPECIFIC.has(rec.kind);
     else if (rec.kind === "sym:file") eligible = !BARE_FILES.has(rec.anchor);
-    // sym:path / sym:ident are intentionally NOT headline-eligible (harness/runtime token noise).
     if (!eligible) continue;
-    // (b) relatedness gate — largest same-root witness group must be >= 2
+    // relatedness gate — largest same-root witness group must be >= 2
     const byRoot = new Map();
     for (const w of rec.sessions.values()) {
       const rk = w.root || "";
@@ -544,9 +1140,6 @@ async function main() {
         topRoot = rk;
       }
     if (topWit.length < 2) continue;
-    // An ERROR string's relatedness comes only from the project it recurs in — the HOME catch-all root is
-    // not a project, so a bare-home error recurrence is not "related context". A FILE anchor is itself the
-    // shared context (same file, different days), so it is allowed to recur across the home root.
     if (rec.kind.startsWith("err") && isHomeRoot(topRoot)) continue;
     topWit.sort((a, b) => (a.turn_idx || 0) - (b.turn_idx || 0));
     let spec = rec.anchor.length + (rec.kind.startsWith("err") ? 20 : 6);
@@ -560,9 +1153,63 @@ async function main() {
       witnesses: topWit,
     });
   }
-  // most-recurring, then most-specific first
   cellA.sort((a, b) => b.relatedN - a.relatedN || b.spec - a.spec);
 
+  // ============ CELL X: CROSS-VENDOR recurrence — the SAME specific anchor across >=2 agents ============
+  // Two disjoint, both-genuine sources:
+  //   (1) errors-with-identifiers + distinctive symbols — from anchorMap. The identical token in two
+  //       agents IS the same entity (portable by construction), so >=2 distinct source tools qualifies.
+  //   (2) files — from filePathMap, keyed by RESOLVED ABSOLUTE IDENTITY. A shared basename is NOT a
+  //       match; only the same actual path across >=2 tools qualifies. proofPath carries that identity
+  //       so the receipt (and the pre-push self-verify) can print the exact shared file.
+  // Each vendor's witnesses stay separate so the receipt reproduces EACH side from its own raw store.
+  const cellX = [];
+  for (const [, rec] of anchorMap) {
+    if (!crossAnchorEligible(rec.kind, rec.anchor, rec.sessions.size)) continue;
+    const byVendor = new Map();
+    for (const w of rec.sessions.values()) {
+      const st = w.source_tool || SRC.claude;
+      if (!byVendor.has(st)) byVendor.set(st, []);
+      byVendor.get(st).push(w);
+    }
+    if (byVendor.size < 2) continue;
+    const perVendor = [...byVendor.entries()].map(([src, ws]) => ({
+      src,
+      witnesses: ws.sort((a, b) => (a.turn_idx || 0) - (b.turn_idx || 0)),
+    }));
+    const spec = rec.anchor.length + (rec.kind.startsWith("err") ? 20 : 6);
+    cellX.push({
+      kind: rec.kind,
+      anchor: rec.anchor,
+      proofPath: null,
+      vendorCount: byVendor.size,
+      totalSessions: rec.sessions.size,
+      perVendor,
+      spec,
+    });
+  }
+  for (const [identity, fe] of filePathMap) {
+    if (fe.byTool.size < 2) continue; // same actual file must appear in >=2 different agents
+    let totalSessions = 0;
+    const perVendor = [...fe.byTool.entries()].map(([src, perSess]) => {
+      const ws = [...perSess.values()].sort((a, b) => (a.turn_idx || 0) - (b.turn_idx || 0));
+      totalSessions += ws.length;
+      return { src, witnesses: ws };
+    });
+    cellX.push({
+      kind: "sym:file",
+      anchor: fe.basename,
+      proofPath: identity, // the exact shared absolute path — the same-file proof
+      vendorCount: fe.byTool.size,
+      totalSessions,
+      perVendor,
+      spec: identity.length + 6,
+    });
+  }
+  cellX.sort(
+    (a, b) => b.vendorCount - a.vendorCount || b.totalSessions - a.totalSessions || b.spec - a.spec,
+  );
+
   // ============ CELL C: density-gated measured spiral (within a session) ============
   const cellC = [];
   for (const s of sessions) {
@@ -600,7 +1247,7 @@ async function main() {
       const first = ts[0],
         last = ts[ts.length - 1];
       const durMin = (last.tms - first.tms) / 60000;
-      if (durMin <= 0 || durMin > 240) continue; // >240min => idle gap, not an active spiral
+      if (durMin <= 0 || durMin > 240) continue;
       const hasUser = s.turns.some(
         (t) =>
           t.role === "user" &&
@@ -610,10 +1257,8 @@ async function main() {
           t.turn_idx < last.turn_idx,
       );
       if (!hasUser) continue;
-      const genericExc = rec.kind === "err:exc"; // bare exception class: weak spiral anchor, demote
+      const genericExc = rec.kind === "err:exc";
       const mid = ts[Math.floor(ts.length / 2)];
-      // center the quoted span on the anchor occurrence so the reader SEES it in the quote (the reproduce
-      // check reads full turn text; without centering the anchor can fall outside the 200-char window).
       const vb = (t) => {
         const full = t.text || t.toolErrText || "";
         const pos = full.toLowerCase().indexOf(rec.anchor.toLowerCase());
@@ -624,6 +1269,7 @@ async function main() {
       cellC.push({
         session_id: s.sessionId,
         root: first.root,
+        source_tool: s.source_tool,
         anchor: rec.anchor,
         kind: rec.kind,
         genericExc,
@@ -636,15 +1282,13 @@ async function main() {
           ts: t.ts,
           role: t.role,
           from: t.mineErrOnly ? "tool_output" : "message",
+          source_tool: t.source_tool,
+          bubbleKey: t.bubbleKey,
           verbatim: vb(t),
         })),
       });
     }
   }
-  // Email-density demotion: a spiral whose witness spans are full of third-party emails is not a single-
-  // cause loop — it is a batch job hitting many different hosts that happen to share one generic errno
-  // (the same cross-context-collision pathology, just inside one session). A PII-clean coding spiral (an
-  // endpoint timing out, a hook aborting) is the real, shareable signal and must rank above it.
   for (const r of cellC) {
     let emails = 0;
     for (const w of r.witnesses) {
@@ -652,9 +1296,6 @@ async function main() {
       if (m) emails += m.length;
     }
     r.emailHits = emails;
-    // >= 2 email hits across the spans = a contact-list batch (many hosts). A lone hit is almost always
-    // an npm spec / version string / git ref false-positive, so it must not demote a clean coding spiral.
-    // (Real emails are redacted from the DISPLAY regardless; this threshold only governs RANKING.)
     r.piiDense = emails >= 2 ? 1 : 0;
   }
   cellC.sort(
@@ -665,45 +1306,55 @@ async function main() {
       b.occurrences - a.occurrences,
   );
 
-  // ============ assemble up to 3 VERIFIED, re-derived relations ============
-  // Every survivor is re-derived from disk; only relations whose anchor is still verbatim in >= 2 cited
-  // sessions/turns are rendered. Bare exception classes and cross-session sym:ident/sym:path hits
-  // (harness/runtime tokens) are computed but NEVER asserted as a cross-session headline.
-  // Editorial order (strongest, most non-obvious first):
-  //   class 1 — the single strongest measured SPIRAL (CELL C): density-gated, single-context, wall-clock.
-  //             This is the most non-obvious signal, so it leads. A generic error CLASS is allowed here
-  //             ONLY because a spiral is one session in one context — it is NOT a cross-context collision.
-  //   class 2 — SPECIFIC cross-session errors sharing a project root (up to 2).
-  //   class 3 — SPECIFIC files you kept returning to in the same project (fill remaining slots).
+  // ============ assemble VERIFIED, re-derived relations (cross-vendor first) ============
+  const usedAnchors = new Set();
+  const anchorKey = (kind, anchor) =>
+    kind.startsWith("sym") ? anchor : kind + "|" + anchor.toLowerCase();
+
+  // --- CELL X: reproduce EACH vendor side independently; keep only survivors that still span >=2 tools.
+  const renderedX = [];
+  for (const r of cellX) {
+    if (renderedX.length >= 2) break;
+    const legs = [];
+    for (const pv of r.perVendor) {
+      const rep = reproduceCount(r.anchor, pv.witnesses);
+      if (rep.confirmed >= 1) legs.push({ src: pv.src, witnesses: pv.witnesses, rep });
+    }
+    if (legs.length < 2) continue; // must still be genuinely cross-vendor after a fresh re-read
+    legs.sort((a, b) => b.rep.confirmed - a.rep.confirmed);
+    renderedX.push({ kind: r.kind, anchor: r.anchor, proofPath: r.proofPath, legs });
+    usedAnchors.add(anchorKey(r.kind, r.anchor));
+  }
+
+  // --- single-vendor findings (CELL C spiral, then CELL A recurrence), skipping anchors already shown.
   const errorsA = cellA.filter((r) => r.kind.startsWith("err"));
   const filesA = cellA.filter((r) => r.kind === "sym:file");
   const rendered = [];
   const takeA = (r) => {
-    const rep = reproduceCount(fileIndex, r.anchor, r.witnesses);
+    if (usedAnchors.has(anchorKey(r.kind, r.anchor))) return false;
+    const rep = reproduceCount(r.anchor, r.witnesses);
     if (rep.confirmed < 2) return false;
     rendered.push({ cell: "A", ...r, rep });
+    usedAnchors.add(anchorKey(r.kind, r.anchor));
     return true;
   };
-
-  // class 1: the single strongest measured spiral
+  const SINGLE_MAX = renderedX.length ? 2 : 3;
   for (const r of cellC) {
-    if (rendered.length >= 3) break;
-    const rep = reproduceCount(fileIndex, r.anchor, r.witnesses);
+    if (rendered.length >= SINGLE_MAX) break;
+    if (usedAnchors.has(anchorKey(r.kind, r.anchor))) continue;
+    const rep = reproduceCount(r.anchor, r.witnesses);
     if (rep.confirmed < 2) continue;
     rendered.push({ cell: "C", ...r, rep });
+    usedAnchors.add(anchorKey(r.kind, r.anchor));
     break;
   }
-
-  // class 2: specific cross-session errors in a shared project (up to 2)
   let c2 = 0;
   for (const r of errorsA) {
-    if (rendered.length >= 3 || c2 >= 2) break;
+    if (rendered.length >= SINGLE_MAX || c2 >= 2) break;
     if (takeA(r)) c2++;
   }
-
-  // class 3: specific files you kept returning to (fill remaining slots)
   for (const r of filesA) {
-    if (rendered.length >= 3) break;
+    if (rendered.length >= SINGLE_MAX) break;
     takeA(r);
   }
 
@@ -711,17 +1362,30 @@ async function main() {
   P();
   P("  skalpel autopsy");
   P("  " + RULE);
+  // per-vendor inventory line — every count re-derives from that vendor's raw store.
+  const invParts = presentVendors
+    .map((v) => `${inv[v].sessions} ${srcLabel(v)}${inv[v].sessions === 1 ? "" : ""}`)
+    .join(" · ");
+  const vendorWord = presentVendors.length === 1 ? "agent" : "agents";
   P(
-    `  read ${sessions.length} local session${sessions.length === 1 ? "" : "s"} · ${totalTurns} turns · nothing left this machine`,
+    `  read ${sessions.length} local session${sessions.length === 1 ? "" : "s"} across ${presentVendors.length} ${vendorWord} · ${totalTurns} turns · nothing left this machine`,
   );
+  if (presentVendors.length) {
+    P(
+      "  " +
+        presentVendors
+          .map((v) => `${srcLabel(v)}: ${inv[v].sessions} sessions / ${inv[v].turns} turns`)
+          .join("   ·   "),
+    );
+  }
   P();
 
-  if (rendered.length === 0) {
-    // HONEST ZERO-STATE — a live counter, never a fabricated finding.
-    P("  No reproducible cross-session relation has crossed the bar yet.");
+  const nothing = renderedX.length === 0 && rendered.length === 0;
+  if (nothing) {
+    P("  No reproducible relation has crossed the bar yet.");
     P();
     if (sessions.length === 0) {
-      P("  There's no Claude Code history on this machine to read.");
+      P("  There's no local agent history on this machine to read.");
     } else {
       P(
         `  verified findings so far: 0  ·  scanned ${totalTurns} turns across ${sessions.length} session${sessions.length === 1 ? "" : "s"}`,
@@ -737,12 +1401,63 @@ async function main() {
     }
     P();
     P("  " + RULE);
-    renderFooter(P);
+    renderNoCrossVendor(P, presentVendors, renderedX.length > 0);
+    renderConnectInvite(P, presentVendors);
+    renderFooter(P, presentVendors);
     process.stdout.write(out.join("\n") + "\n");
     return;
   }
 
   let n = 0;
+
+  // --- CELL X (cross-vendor) leads: the finding no single model vendor can produce.
+  for (const rx of renderedX) {
+    n++;
+    P(`  ${n}.  ⟷ CROSS-VENDOR`);
+    const names = rx.legs.map((l) => srcLabel(l.src));
+    const nameList =
+      names.length === 2
+        ? `${names[0]} and ${names[1]}`
+        : names.slice(0, -1).join(", ") + ", and " + names.slice(-1);
+    const counts = rx.legs.map((l) => `${l.rep.total} in ${srcLabel(l.src)}`).join(", ");
+    if (rx.kind === "sym:file") {
+      P(`  The SAME FILE followed you across ${nameList} (${counts}):`);
+      P(`    ${redact(rx.proofPath)}`);
+      P(`  — same absolute path in every agent, not just a shared filename.`);
+    } else if (rx.kind.startsWith("err")) {
+      P(`  ${plainAnchor(rx.kind, rx.anchor)} appears in BOTH ${nameList} — the same specific`);
+      P(`  error surfaced in more than one agent (${counts}).`);
+    } else {
+      P(`  ${plainAnchor(rx.kind, rx.anchor)} appears in BOTH ${nameList} — the same distinctive`);
+      P(`  symbol carried across more than one agent (${counts}).`);
+    }
+    P(`  No single model vendor can see this; it needs all your logs at once.`);
+    P();
+    for (const leg of rx.legs) {
+      P(`    ── ${srcLabel(leg.src)} ──`);
+      for (const w of leg.witnesses.slice(0, 2)) {
+        P(
+          `    ${short(w.session_id)} · turn ${w.turn_idx} · ${shortTs(w.ts)} · ${srcTag(w)}${projLabel(w.root)}`,
+        );
+        P(`      "${redact(w.verbatim)}"`);
+      }
+    }
+    P();
+    P(`    reproduce: re-open EACH agent's raw store fresh and re-confirm the anchor —`);
+    for (const leg of rx.legs) {
+      P(
+        `      ${srcLabel(leg.src)}: present verbatim in ${leg.rep.confirmed}/${leg.rep.total} cited sessions`,
+      );
+      for (const w of leg.witnesses.slice(0, 2)) {
+        const p = srcPointer(w);
+        if (p) P(`        ${p}`);
+      }
+    }
+    P();
+    P("  " + RULE);
+  }
+
+  // --- single-vendor findings
   for (const r of rendered) {
     n++;
     P(`  ${n}.`);
@@ -750,25 +1465,24 @@ async function main() {
       const shown = r.witnesses.slice(0, 3);
       const proj = projTail(r.root);
       const where = proj ? ` in ${proj}` : "";
+      const tool = srcLabel(shown[0] && shown[0].source_tool);
       if (r.kind === "sym:file") {
-        // "returning to a file" is a behavior sourced from either side; the FILENAME is the shared context.
         P(`  You kept returning to the file ${r.anchor} across ${r.relatedN} separate`);
-        P(`  sessions${where} — the same file, on different days.`);
+        P(`  ${tool} sessions${where} — the same file, on different days.`);
       } else {
-        // errors here are compiler/runtime output — sourced to the SESSION, never "you hit".
         const anyUser = shown.some(isUserTyped);
         if (anyUser) {
           P(`  ${plainAnchor(r.kind, r.anchor)} came up across ${r.relatedN} separate`);
-          P(`  sessions${where} — the same specific error, on different days.`);
+          P(`  ${tool} sessions${where} — the same specific error, on different days.`);
         } else {
-          P(`  Your sessions hit ${plainAnchor(r.kind, r.anchor)} across ${r.relatedN}`);
+          P(`  Your ${tool} sessions hit ${plainAnchor(r.kind, r.anchor)} across ${r.relatedN}`);
           P(`  separate sessions${where} — the same specific error resurfaced across days.`);
         }
       }
       P();
       for (const w of shown) {
         P(
-          `    ${short(w.session_id)} · turn ${w.turn_idx} · ${shortTs(w.ts)} · ${srcTag(w)}${projLabel(w.root)}`,
+          `    ${short(w.session_id)} · turn ${w.turn_idx} · ${shortTs(w.ts)} · ${srcTag(w)} · ${srcLabel(w.source_tool)}${projLabel(w.root)}`,
         );
         P(`      "${redact(w.verbatim)}"`);
       }
@@ -776,17 +1490,19 @@ async function main() {
       P(`    reproduce: re-read the cited sessions fresh from disk at the cited`);
       P(`    turns → anchor present verbatim in ${r.rep.confirmed}/${r.rep.total} cited sessions`);
       P(
-        `    (${r.rep.total - r.rep.confirmed} false join${r.rep.total - r.rep.confirmed === 1 ? "" : "s"}). Files:`,
+        `    (${r.rep.total - r.rep.confirmed} false join${r.rep.total - r.rep.confirmed === 1 ? "" : "s"}). Sources:`,
       );
       for (const w of shown) {
-        const f = fileIndex.get(w.session_id);
-        if (f) P(`      ${f}  @turn ${w.turn_idx}`);
+        const p = srcPointer(w);
+        if (p) P(`      ${p}`);
       }
     } else {
-      // CELL C — measured spiral. State the mechanical fact; the quoted turns self-adjudicate.
       const proj = projTail(r.root);
       const where = proj ? ` in ${proj}` : "";
-      P(`  ${plainAnchor(r.kind, r.anchor)} recurred ${r.occurrences}× inside one session${where}`);
+      const tool = srcLabel(r.source_tool);
+      P(
+        `  ${plainAnchor(r.kind, r.anchor)} recurred ${r.occurrences}× inside one ${tool} session${where}`,
+      );
       P(
         `  over a ${r.duration_min}-minute window (wall-clock), across ${r.distinct_turns} turns with`,
       );
@@ -796,7 +1512,7 @@ async function main() {
       for (const w of r.witnesses) {
         const mark = isUserTyped(w) ? "●" : "○";
         P(
-          `    ${mark} ${short(w.session_id)} · turn ${w.turn_idx} · ${shortTs(w.ts)}${projLabel(w.root)}`,
+          `    ${mark} ${short(w.session_id)} · turn ${w.turn_idx} · ${shortTs(w.ts)} · ${srcLabel(w.source_tool)}${projLabel(w.root)}`,
         );
         P(`      "${redact(w.verbatim)}"`);
       }
@@ -805,23 +1521,69 @@ async function main() {
       P(
         `    anchor present verbatim at all ${r.rep.confirmed}/${r.rep.total} cited turns (of ${r.occurrences} total`,
       );
-      P(`    occurrences); the ${r.duration_min}min span = last.ts − first.ts, both quoted. File:`);
-      const f = fileIndex.get(r.session_id);
-      if (f) P(`      ${f}`);
+      P(
+        `    occurrences); the ${r.duration_min}min span = last.ts − first.ts, both quoted. Source:`,
+      );
+      const p = srcPointer(r.witnesses[0]);
+      if (p) P(`      ${p}`);
     }
     P();
     P("  " + RULE);
   }
 
-  renderFooter(P);
+  // --- honest cross-vendor status: strict miss when >=2 agents present, or a connect invite for one.
+  renderNoCrossVendor(P, presentVendors, renderedX.length > 0);
+  renderConnectInvite(P, presentVendors);
+  renderFooter(P, presentVendors);
   process.stdout.write(out.join("\n") + "\n");
 }
 
-function renderFooter(P) {
+// When >=2 agents ARE connected but nothing genuinely crosses between them, say so plainly instead of
+// manufacturing a basename-collision "match". This is the honest counterpart to a real CELL X finding.
+function renderNoCrossVendor(P, presentVendors, hasCrossVendor) {
+  if (presentVendors.length < 2 || hasCrossVendor) return;
+  const names = presentVendors.map(srcLabel);
+  const list =
+    names.length === 2
+      ? names.join(" and ")
+      : names.slice(0, -1).join(", ") + ", and " + names.slice(-1);
+  P();
+  P(`  No same-file or same-error crossed your tools yet (read: ${list}).`);
+  P(`  Cross-vendor is deliberately strict: it fires only when the SAME actual file`);
+  P(`  path — or the SAME specific error/symbol — shows up in two different agents.`);
+  P(`  A shared filename across different projects is NOT a match and is suppressed.`);
+  P(`  Keep working across your tools; the first genuine crossing renders itself here.`);
+  P();
+  P("  " + RULE);
+}
+
+// When only ONE agent has usable history, the cross-vendor verdict cannot exist yet. Say so honestly
+// and invite a second connection — the multi-vendor connect is the whole point of this cell.
+function renderConnectInvite(P, presentVendors) {
+  if (presentVendors.length !== 1) return;
+  const have = srcLabel(presentVendors[0]);
+  const others = ["Cursor", "Codex", "Aider"].filter((x) => x !== have);
+  P();
+  P(`  You've connected ONE agent so far: ${have}.`);
+  P(`  The signal no model vendor can build for you is CROSS-VENDOR — which tool`);
+  P(`  actually LANDS a pattern you keep reopening in another. Connect a 2nd agent`);
+  P(`  (${others.join(" / ")}) and the next autopsy will show where the SAME error or`);
+  P(`  file follows you across tools — reproduced from each tool's own local logs.`);
+  P();
+  P("  " + RULE);
+}
+
+function renderFooter(P, presentVendors) {
+  const stores = [];
+  if (presentVendors.includes(SRC.claude)) stores.push("~/.claude/projects");
+  if (presentVendors.includes(SRC.codex)) stores.push("~/.codex/sessions");
+  if (presentVendors.includes(SRC.cursor)) stores.push("Cursor state.vscdb");
+  if (presentVendors.includes(SRC.aider)) stores.push("~/.aider.chat.history.md");
+  const storeList = stores.length ? stores.join(", ") : "your local agent logs";
   P();
   P("  This receipt was generated locally, read-only, with zero network calls —");
-  P("  rendered from files already on your disk (~/.claude/projects, ~/.skalpel).");
-  P("  Every number above re-derives from the raw logs at the cited turns.");
+  P(`  rendered from agent logs already on your disk (${storeList}).`);
+  P("  Every number above re-derives from the raw logs at the cited turns, per vendor.");
   P();
   if (RAW) {
     P("  --raw: third-party emails / domains / IPs / secrets are shown UNREDACTED");
@@ -831,9 +1593,9 @@ function renderFooter(P) {
     P("  spans are redacted to [email]/[domain]/[ip]/[token]. Run with --raw to reveal.");
   }
   P();
-  P("  Honest scope: this AUTOPSY is local. The rest of skalpel is not yet —");
-  P("  the per-turn hook and session-end ingest still upload transcripts today.");
-  P("  Zero-network ingest is a later cycle; this receipt is the first step.");
+  P("  Honest scope: this AUTOPSY is local and cross-vendor. The rest of skalpel is");
+  P("  not yet — the per-turn hook and session-end ingest still upload transcripts");
+  P("  today. Zero-network ingest is a later cycle; this receipt is the first step.");
   P();
 }