@diffin/cli 0.0.0-stage → 0.1.0

package/lib/sources/antigravity.mjs

@@ -0,0 +1,178 @@
+// Antigravity CLI adapter. Same contract as the others — detect / enumerate / tsOf / currentSession.
+//
+// A conversation is kept twice under ~/.gemini/antigravity-cli: as protobuf rows in conversations/<id>.db, and as a
+// plain log, brain/<id>/.system_generated/logs/transcript_full.jsonl, one JSON row per step (read 2026-10-04, CLI
+// 1.2.16). The plain log is what is read: it holds the same steps with their times, and reading the protobuf would mean
+// carrying Antigravity's schema. `transcript.jsonl` beside it is the same log with long fields CUT (`truncated_fields`),
+// so it is only the fallback.
+//
+// Which conversations exist, where each was made and whose child it is come from conversation_summaries.db — the
+// index Antigravity itself lists conversations from. A sub-agent is a conversation of its own with a
+// `parent_conversation_id`; it rides under its parent. Without that index a sub-agent's first step — its parent's
+// instruction to it, stored as a user step — would be recorded as something the person said, so when the index cannot
+// be read nothing is offered at all.
+//
+// What is taken from a row: the person's step with Antigravity's wrapper removed (the text sits in <USER_REQUEST>,
+// beside an <ADDITIONAL_METADATA> block the person did not type), the agent's reply, and of a tool call its name and
+// the one argument SCAN reads (a command, a file path, a query). Tool output (`GENERIC` rows) and `thinking` are
+// never put into a row.
+import { createReadStream, existsSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createInterface } from 'node:readline';
+import { projectDirOf } from './project-dir.mjs';
+
+const ROOT = () => join(process.env.DIFFIN_HOME ?? homedir(), '.gemini', 'antigravity-cli');
+const INDEX = () => join(ROOT(), 'conversation_summaries.db');
+const logOf = (id) => {
+  const dir = join(ROOT(), 'brain', id, '.system_generated', 'logs');
+  const full = join(dir, 'transcript_full.jsonl');
+  return existsSync(full) ? full : join(dir, 'transcript.jsonl');
+};
+
+let _sqlite = null;
+function sqlite() {
+  if (_sqlite) return _sqlite;
+  // node:sqlite prints an ExperimentalWarning nobody can act on (see hermes.mjs): drop that one warning only
+  const orig = process.emitWarning.bind(process);
+  process.emitWarning = (warning, ...rest) => {
+    const type = rest[0]?.type ?? rest[0];
+    const msg = typeof warning === 'string' ? warning : warning?.message ?? '';
+    if ((type === 'ExperimentalWarning' || warning?.name === 'ExperimentalWarning') && /SQLite/i.test(msg)) return;
+    return orig(warning, ...rest);
+  };
+  _sqlite = process.getBuiltinModule ? process.getBuiltinModule('node:sqlite') : null;
+  if (!_sqlite) throw new Error('node:sqlite unavailable (node < 22.5)');
+  return _sqlite;
+}
+
+const folderOf = (uris) => {
+  try { const u = JSON.parse(String(uris ?? '[]'))[0]; return u ? (String(u).startsWith('file:') ? fileURLToPath(u) : String(u)) : ''; } catch { return ''; }
+};
+
+/** every conversation the index knows: { id, cwd, parent, last } — or null when the index cannot be read */
+function conversations() {
+  if (!existsSync(INDEX())) return null;
+  let d;
+  try { d = new (sqlite().DatabaseSync)(INDEX(), { readOnly: true }); } catch { return null; }
+  try {
+    return d.prepare('SELECT conversation_id, workspace_uris, parent_conversation_id, last_modified_time FROM conversation_summaries').all().map((r) => {
+      const id = String(r.conversation_id);
+      // the index is written when a turn ends; the log is written as it goes — whichever moved last
+      let last = Date.parse(String(r.last_modified_time ?? '').replace(' ', 'T')) || 0;
+      try { last = Math.max(last, statSync(logOf(id)).mtimeMs); } catch { /* no log yet */ }
+      return { id, cwd: folderOf(r.workspace_uris), parent: r.parent_conversation_id ? String(r.parent_conversation_id) : null, last };
+    }).filter((c) => /^[0-9a-f-]{8,64}$/i.test(c.id));
+  } catch { return null; }
+  finally { try { d.close(); } catch { /* closing */ } }
+}
+
+/** what the person typed, out of the wrapper Antigravity stores it in */
+export function typedText(content) {
+  const s = String(content ?? '');
+  const a = s.indexOf('<USER_REQUEST>'), b = s.lastIndexOf('</USER_REQUEST>');
+  if (a >= 0 && b > a) return s.slice(a + 14, b).trim();
+  // no wrapper: the text as it is, without a metadata block if one stands after it
+  const m = s.indexOf('<ADDITIONAL_METADATA>');
+  return (m >= 0 ? s.slice(0, m) : s).trim();
+}
+
+// an argument is sometimes stored as a JSON string of the string
+const arg = (v) => { const s = String(v ?? ''); if (s.length > 1 && s.startsWith('"') && s.endsWith('"')) { try { return String(JSON.parse(s)); } catch { /* as it is */ } } return s; };
+
+/** Antigravity's tool call → the marker name SCAN reads, with the one argument it reads; a tool with none is dropped */
+function mapTool(t) {
+  const a = t?.args && typeof t.args === 'object' ? t.args : {};
+  switch (t?.name) {
+    case 'run_command': return { name: 'Bash', input: { command: arg(a.CommandLine) } };
+    case 'write_to_file': return { name: 'Write', input: { file_path: arg(a.TargetFile) } };
+    case 'replace_file_content': case 'multi_replace_file_content': return { name: 'Edit', input: { file_path: arg(a.TargetFile) } };
+    case 'search_web': return { name: 'WebSearch', input: { query: arg(a.query) } };
+    case 'read_url_content': return { name: 'WebFetch', input: { url: arg(a.Url ?? a.url) } };
+    default: return null;
+  }
+}
+
+/** one conversation's log → Claude Code-shaped rows */
+async function* conversationRows(id, cwd, { sidechain = false } = {}) {
+  const path = logOf(id);
+  if (!existsSync(path)) return;
+  const rl = createInterface({ input: createReadStream(path, 'utf8'), crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let r;
+    try { r = JSON.parse(line); } catch { continue; } // the last line of a live log may be torn
+    const base = { uuid: `ag:${id}:${r.step_index}`, timestamp: r.created_at, cwd, ...(sidechain ? { isSidechain: true } : {}) };
+    if (r.type === 'USER_INPUT') {
+      // only what the person sent: a step Antigravity put there on its own carries another source
+      if (r.source !== 'USER_EXPLICIT') continue;
+      const text = typedText(r.content);
+      if (text) yield { type: 'user', ...base, message: { role: 'user', content: text } };
+    } else if (r.type === 'PLANNER_RESPONSE') {
+      const blocks = [];
+      if (typeof r.content === 'string' && r.content.trim()) blocks.push({ type: 'text', text: r.content });
+      (Array.isArray(r.tool_calls) ? r.tool_calls : []).forEach((t, k) => {
+        const m = mapTool(t);
+        if (m && Object.values(m.input)[0]) blocks.push({ type: 'tool_use', id: `${r.step_index}:${k}`, name: m.name, input: m.input });
+      });
+      if (!blocks.length) continue;
+      const num = (v) => (typeof v === 'number' ? v : undefined);
+      const usage = { input_tokens: num(r.input_tokens), output_tokens: num(r.output_tokens), cache_read_input_tokens: num(r.cache_read_tokens) };
+      yield { type: 'assistant', ...base, message: { role: 'assistant', content: blocks, ...(Object.values(usage).some((v) => v !== undefined) ? { usage } : {}) } };
+    }
+    // GENERIC rows are tool output; `thinking` is on the row and never copied
+  }
+}
+
+const rootOf = (c, byId) => { let cur = c; for (let i = 0; i < 8 && cur?.parent; i++) cur = byId.get(cur.parent); return cur && !cur.parent ? cur : null; };
+
+export const antigravity = {
+  name: 'antigravity',
+
+  detect() {
+    const all = conversations();
+    if (!all) return null;
+    const n = all.filter((c) => !c.parent && existsSync(logOf(c.id))).length;
+    return { present: n > 0, sessions: n };
+  },
+
+  enumerate({ from }) {
+    const all = conversations();
+    if (!all) return [];
+    const fromMs = new Date(from).getTime();
+    const byId = new Map(all.map((c) => [c.id, c]));
+    const kids = new Map();
+    for (const c of all) { if (!c.parent) continue; const root = rootOf(c, byId); if (root) kids.set(root.id, [...(kids.get(root.id) ?? []), c]); }
+    return all.filter((c) => !c.parent && existsSync(logOf(c.id))).map((c) => {
+      const subs = (kids.get(c.id) ?? []).filter((s) => existsSync(logOf(s.id)));
+      return {
+        sid: 'ag-' + c.id,
+        projectDir: projectDirOf(c.cwd),
+        files: [
+          { path: 'main', rows: () => conversationRows(c.id, c.cwd) },
+          ...subs.map((s) => ({ path: `subagents/${s.id}.jsonl`, rows: () => conversationRows(s.id, s.cwd || c.cwd, { sidechain: true }) })),
+        ],
+        last: Math.max(c.last, ...subs.map((s) => s.last)),
+        cwd: c.cwd,
+      };
+    }).filter((e) => e.last >= fromMs);
+  },
+
+  tsOf(r) { return r?.timestamp ? new Date(r.timestamp).getTime() : 0; },
+
+  /**
+   * The conversation a capture is for: the one Antigravity names in ANTIGRAVITY_CONVERSATION_ID (set for every
+   * command it runs) — or its parent, when that is a sub-agent — else the conversation of this folder that moved last.
+   */
+  currentSession(cwd = process.cwd(), env = process.env) {
+    const all = conversations();
+    if (!all) return null;
+    const byId = new Map(all.map((c) => [c.id, c]));
+    const named = env.ANTIGRAVITY_CONVERSATION_ID && byId.get(String(env.ANTIGRAVITY_CONVERSATION_ID));
+    const root = named ? rootOf(named, byId) : null;
+    if (root) return { sid: 'ag-' + root.id, id: root.id, cwd: root.cwd, how: 'env' };
+    const here = all.filter((c) => !c.parent && c.cwd === cwd).sort((a, b) => b.last - a.last)[0];
+    return here ? { sid: 'ag-' + here.id, id: here.id, cwd: here.cwd, how: 'newest' } : null;
+  },
+};

package/lib/sources/claude-code.mjs

@@ -0,0 +1,107 @@
+// Claude Code adapter. Sessions are <root>/<encoded-project-dir>/<sid>.jsonl, with
+// subagent transcripts under <sid>/subagents/**.jsonl. Every row carries an ISO
+// `timestamp`, which is the time key the range cut uses — so a long-running session
+// contributes only its turns inside the window, not all-or-nothing on its start time.
+import { closeSync, createReadStream, existsSync, fstatSync, openSync, readdirSync, readSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+
+const ROOT = join(process.env.DIFFIN_HOME ?? homedir(), '.claude', 'projects');
+
+function projectDirs() {
+  try {
+    return readdirSync(ROOT, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch { return []; }
+}
+
+/**
+ * The folder a session was last in, read from the END of its transcript: a session
+ * keeps writing to the project dir it began in after the person cd's elsewhere, so the
+ * first row's folder is where it started, not where it is. The last 256KB are enough —
+ * every row carries its cwd — and a torn first line of the chunk simply fails to parse.
+ */
+function tailCwd(path) {
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+    const size = fstatSync(fd).size;
+    const len = Math.min(size, 256 * 1024);
+    const buf = Buffer.alloc(len);
+    readSync(fd, buf, 0, len, size - len);
+    const lines = buf.toString('utf8').split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (!lines[i].includes('"cwd"')) continue;
+      try { const r = JSON.parse(lines[i]); if (r?.cwd) return String(r.cwd); } catch { /* torn */ }
+    }
+    return null;
+  } catch { return null; }
+  finally { if (fd !== undefined) try { closeSync(fd); } catch { /* closing */ } }
+}
+
+// rows of one jsonl file, one at a time; a torn line is skipped (the pipeline's scan
+// skips it too, so shipping it would only spend bytes)
+async function* fileRows(path) {
+  const rl = createInterface({ input: createReadStream(path, 'utf8'), crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    try { yield JSON.parse(line); } catch { /* torn */ }
+  }
+}
+
+export const claudeCode = {
+  name: 'cc',
+
+  detect() {
+    if (!existsSync(ROOT)) return null;
+    let sessions = 0;
+    for (const d of projectDirs()) {
+      try { sessions += readdirSync(join(ROOT, d)).filter((f) => f.endsWith('.jsonl') && !f.startsWith('._')).length; }
+      catch { /* skip */ }
+    }
+    return { present: sessions > 0, sessions };
+  },
+
+  // A session is a candidate if its file was modified within the window — a cheap
+  // mtime prefilter. The per-row cut then keeps only in-window rows, so a session that
+  // started long ago but was touched inside the window still counts.
+  // Each entry lists its files, each with a rows() thunk — nothing is read here.
+  enumerate({ from }) {
+    const fromMs = new Date(from).getTime();
+    const out = [];
+    for (const projectDir of projectDirs()) {
+      const abs = join(ROOT, projectDir);
+      let names;
+      try { names = readdirSync(abs); } catch { continue; }
+      for (const f of names) {
+        if (!f.endsWith('.jsonl') || f.startsWith('._')) continue;
+        const path = join(abs, f);
+        let mtime = 0;
+        try { mtime = statSync(path).mtimeMs; } catch { continue; }
+        if (mtime < fromMs) continue;
+        const sid = f.replace(/\.jsonl$/, '');
+        const files = [{ path: 'main', rows: () => fileRows(path) }];
+        const subDir = join(abs, sid, 'subagents');
+        if (existsSync(subDir)) {
+          for (const p of walkJsonl(subDir)) {
+            files.push({ path: `subagents/${p.slice(subDir.length + 1)}`, rows: () => fileRows(p) });
+          }
+        }
+        // `last`: when the session last moved — the file's mtime is its last row. A
+        // capture of every session sends it so the server can skip what has not moved.
+        out.push({ sid, projectDir, files, last: mtime, lastCwd: () => tailCwd(path) });
+      }
+    }
+    return out;
+  },
+
+  tsOf(r) { return r?.timestamp ? new Date(r.timestamp).getTime() : 0; },
+};
+
+function* walkJsonl(dir) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) yield* walkJsonl(p);
+    else if (e.name.endsWith('.jsonl')) yield p;
+  }
+}

package/lib/sources/codex.mjs

@@ -0,0 +1,230 @@
+// Codex CLI adapter. Same contract as the others — detect / enumerate / tsOf / currentSession.
+//
+// A Codex thread is one file: ~/.codex/sessions/YYYY/MM/DD/rollout-<local time>-<thread id>.jsonl, appended to for as
+// long as the thread lives (a resume writes on into the same file — checked 2026-10-04). A sub-agent is a thread of
+// its own, in its own file, whose first row names its parent (`parent_thread_id`); it rides with its parent the way a
+// Claude Code sub-agent's transcript does.
+//
+// What is read, and why not the rest. Every message is in the file TWICE — as the model's wire item (`response_item`)
+// and as a completed item of the turn (`event_msg` / `item_completed`). The wire side also carries what Codex itself
+// put in front of the model under the role `user` (an <environment_context> block, per turn) and under `developer`
+// (its instructions); the completed-item side holds exactly what the person typed (`UserMessage`), what the agent
+// said (`AgentMessage`), each command it ran (`CommandExecution`, with the command as argv) and each file it changed
+// (`FileChange`, keyed by path). So the completed items are the transcript, and nothing else is read: measured on the
+// first session of this machine, 4 wire rows of role `user` against 3 things the person typed.
+//
+// Rows come out in Claude Code's shape, so the upload diet (scrub.mjs) and SCAN treat them as they treat any other.
+// Command output, file contents and reasoning are never put into a row at all.
+import { closeSync, createReadStream, existsSync, fstatSync, openSync, readdirSync, readSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { projectDirOf } from './project-dir.mjs';
+
+const ROOT = () => join(process.env.DIFFIN_HOME ?? homedir(), '.codex', 'sessions');
+const FILE = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
+
+/** every rollout file under the sessions tree: { path, id, mtime } */
+function rollouts() {
+  const out = [];
+  const walk = (dir, depth) => {
+    let names;
+    try { names = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of names) {
+      const p = join(dir, e.name);
+      if (e.isDirectory()) { if (depth < 3) walk(p, depth + 1); continue; }
+      const m = FILE.exec(e.name);
+      if (!m) continue;
+      try { out.push({ path: p, id: m[1], mtime: statSync(p).mtimeMs }); } catch { /* gone */ }
+    }
+  };
+  walk(ROOT(), 0);
+  return out;
+}
+
+/** a thread's first row — who it is, where it began, whose child it is. The row carries Codex's base instructions,
+ *  so it can be long; read until its newline, bounded. */
+function meta(path) {
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+    const chunks = []; let at = 0;
+    for (let i = 0; i < 64; i++) {
+      const buf = Buffer.alloc(64 * 1024);
+      const n = readSync(fd, buf, 0, buf.length, at);
+      if (!n) break;
+      const nl = buf.subarray(0, n).indexOf(10);
+      chunks.push(buf.subarray(0, nl >= 0 ? nl : n));
+      if (nl >= 0) break;
+      at += n;
+    }
+    const row = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    const p = row?.type === 'session_meta' ? row.payload : null;
+    if (!p?.id) return null;
+    return {
+      id: String(p.id),
+      cwd: typeof p.cwd === 'string' ? p.cwd : '',
+      parent: typeof p.parent_thread_id === 'string' ? p.parent_thread_id : null,
+      // a sub-agent's file opens with a copy of its parent's rows; its own begin at this ordinal
+      startOrdinal: Number.isFinite(p.subagent_history_start_ordinal) ? p.subagent_history_start_ordinal : 0,
+    };
+  } catch { return null; }
+  finally { if (fd !== undefined) try { closeSync(fd); } catch { /* closing */ } }
+}
+
+/** the folder the thread was last in: the last turn's `cwd`, read from the end of the file */
+function tailCwd(path) {
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+    const size = fstatSync(fd).size;
+    const len = Math.min(size, 512 * 1024);
+    const buf = Buffer.alloc(len);
+    readSync(fd, buf, 0, len, size - len);
+    const lines = buf.toString('utf8').split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (!lines[i].includes('"turn_context"')) continue;
+      try { const r = JSON.parse(lines[i]); if (r?.type === 'turn_context' && r.payload?.cwd) return String(r.payload.cwd); } catch { /* torn */ }
+    }
+    return null;
+  } catch { return null; }
+  finally { if (fd !== undefined) try { closeSync(fd); } catch { /* closing */ } }
+}
+
+const textOf = (content) => (Array.isArray(content) ? content : []).map((c) => (typeof c?.text === 'string' ? c.text : '')).filter(Boolean).join('\n');
+
+/**
+ * argv → the shell tool it was and the command a person would read. Codex runs `<shell> -lc <command>` (seen:
+ * /bin/zsh -lc …); on Windows the shell is PowerShell or cmd, whose flag is `-Command` or `/c` and may stand after
+ * others (`-NoProfile`). The tool's name matters downstream: a PowerShell command's written files are read by
+ * PowerShell's grammar (scrub.mjs). The Windows shapes are written from how those shells are invoked, not from a
+ * session recorded on Windows — none exists yet; anything unrecognised is the argv joined, read as a Bash line.
+ */
+export function shellCall(argv) {
+  if (!Array.isArray(argv)) return { name: 'Bash', command: typeof argv === 'string' ? argv : '' };
+  const a = argv.map(String);
+  const exe = (a[0] ?? '').split(/[\\/]/).pop().toLowerCase().replace(/\.exe$/, '');
+  const name = exe === 'powershell' || exe === 'pwsh' ? 'PowerShell' : 'Bash';
+  const flag = a.findIndex((x, i) => i > 0 && (/^-[a-z]*c$/.test(x) || /^-(c|command)$/i.test(x) || /^\/c$/i.test(x)));
+  return { name, command: flag > 0 && flag < a.length - 1 ? a.slice(flag + 1).join(' ') : a.join(' ') };
+}
+
+/**
+ * One rollout file → Claude Code-shaped rows. An assistant row is held back one step so the usage record that
+ * follows the model's response can be put on it (SCAN charges tokens to the turn from the assistant rows).
+ */
+async function* threadRows(path, { sidechain = false, startOrdinal = 0 } = {}) {
+  const rl = createInterface({ input: createReadStream(path, 'utf8'), crlfDelay: Infinity });
+  let cwd = '', model = '', held = null;
+  const flush = function* () { if (held) { const h = held; held = null; yield h; } };
+  const assistant = (id, ts, content) => ({
+    type: 'assistant', uuid: `cx:${id}`, timestamp: ts, cwd, ...(sidechain ? { isSidechain: true } : {}),
+    message: { role: 'assistant', ...(model ? { model } : {}), content },
+  });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let r;
+    try { r = JSON.parse(line); } catch { continue; } // the last line of a live file may be torn
+    const p = r?.payload;
+    if (!p || typeof p !== 'object') continue;
+    if (r.type === 'session_meta') { if (!cwd && typeof p.cwd === 'string') cwd = p.cwd; continue; }
+    if (r.type === 'turn_context') { if (typeof p.cwd === 'string') cwd = p.cwd; if (typeof p.model === 'string') model = p.model; continue; }
+    if (typeof r.ordinal === 'number' && r.ordinal < startOrdinal) continue; // the parent's rows, copied into a sub-agent's file
+    if (r.type === 'token_usage_record') {
+      const u = p.usage;
+      if (held && u && typeof u === 'object') {
+        const add = (k, v) => { if (typeof v === 'number') held.message.usage = { ...(held.message.usage ?? {}), [k]: (held.message.usage?.[k] ?? 0) + v }; };
+        // Codex counts cached input INSIDE input_tokens; the ledger's four counters keep them apart, as Claude Code's do
+        const cached = typeof u.cached_input_tokens === 'number' ? u.cached_input_tokens : 0;
+        add('input_tokens', typeof u.input_tokens === 'number' ? Math.max(0, u.input_tokens - cached) : undefined);
+        add('output_tokens', u.output_tokens);
+        add('cache_read_input_tokens', cached);
+        add('cache_creation_input_tokens', u.cache_write_input_tokens);
+      }
+      continue;
+    }
+    if (r.type !== 'event_msg' || p.type !== 'item_completed' || !p.item || typeof p.item !== 'object') continue;
+    const it = p.item, ts = r.timestamp, id = String(it.id ?? `${p.turn_id ?? ''}:${r.ordinal ?? ''}`);
+    if (it.type === 'UserMessage') {
+      yield* flush();
+      const text = textOf(it.content);
+      if (text) yield { type: 'user', uuid: `cx:${id}`, timestamp: ts, cwd, ...(sidechain ? { isSidechain: true } : {}), message: { role: 'user', content: text } };
+    } else if (it.type === 'AgentMessage') {
+      yield* flush();
+      const text = textOf(it.content);
+      if (text) held = assistant(id, ts, [{ type: 'text', text }]);
+    } else if (it.type === 'CommandExecution') {
+      yield* flush();
+      const { name, command } = shellCall(it.command);
+      if (command) held = assistant(id, ts, [{ type: 'tool_use', id, name, input: { command } }]);
+    } else if (it.type === 'FileChange') {
+      yield* flush();
+      const blocks = Object.entries(it.changes && typeof it.changes === 'object' ? it.changes : {}).slice(0, 50)
+        .map(([file, ch], k) => ({ type: 'tool_use', id: `${id}:${k}`, name: ch?.type === 'add' ? 'Write' : 'Edit', input: { file_path: file } }));
+      if (blocks.length) held = assistant(id, ts, blocks);
+    }
+    // everything else — reasoning, searches, sub-agent bookkeeping, output — stays on the machine
+  }
+  yield* flush();
+}
+
+/** the threads of the window, sub-agents folded under the thread that spawned them */
+function threads(fromMs) {
+  const files = rollouts().filter((f) => f.mtime >= fromMs).map((f) => ({ ...f, meta: meta(f.path) })).filter((f) => f.meta);
+  const byId = new Map(files.map((f) => [f.meta.id, f]));
+  const rootOf = (f) => { let cur = f; for (let i = 0; i < 8 && cur?.meta.parent; i++) cur = byId.get(cur.meta.parent); return cur && !cur.meta.parent ? cur : null; };
+  const mains = files.filter((f) => !f.meta.parent);
+  const kids = new Map();
+  for (const f of files) {
+    if (!f.meta.parent) continue;
+    const root = rootOf(f); // a sub-agent whose parent is not in the window has nothing of the window to add
+    if (root) kids.set(root.meta.id, [...(kids.get(root.meta.id) ?? []), f]);
+  }
+  return mains.map((f) => ({ main: f, subs: kids.get(f.meta.id) ?? [] }));
+}
+
+export const codex = {
+  name: 'codex',
+
+  detect() {
+    if (!existsSync(ROOT())) return null;
+    const n = rollouts().length;
+    return { present: n > 0, sessions: n };
+  },
+
+  enumerate({ from }) {
+    const fromMs = new Date(from).getTime();
+    return threads(fromMs).map(({ main, subs }) => ({
+      sid: 'cx-' + main.meta.id,
+      projectDir: projectDirOf(main.meta.cwd),
+      files: [
+        { path: 'main', rows: () => threadRows(main.path) },
+        ...subs.map((s) => ({ path: `subagents/${s.meta.id}.jsonl`, rows: () => threadRows(s.path, { sidechain: true, startOrdinal: s.meta.startOrdinal }) })),
+      ],
+      last: Math.max(main.mtime, ...subs.map((s) => s.mtime)),
+      cwd: main.meta.cwd,
+      lastCwd: () => tailCwd(main.path),
+    }));
+  },
+
+  tsOf(r) { return r?.timestamp ? new Date(r.timestamp).getTime() : 0; },
+
+  /**
+   * The thread a capture is for: the one Codex names in CODEX_THREAD_ID (it sets that for every command it runs) —
+   * or, when that names a sub-agent, the thread that spawned it — else the thread of this folder that moved last.
+   */
+  currentSession(cwd = process.cwd(), env = process.env) {
+    const all = rollouts();
+    const named = env.CODEX_THREAD_ID;
+    if (named) {
+      let f = all.find((x) => x.id === named), m = f && meta(f.path);
+      for (let i = 0; i < 8 && m?.parent; i++) { f = all.find((x) => x.id === m.parent); m = f && meta(f.path); }
+      if (m && !m.parent) return { sid: 'cx-' + m.id, id: m.id, cwd: m.cwd, how: 'env' };
+    }
+    for (const f of all.sort((a, b) => b.mtime - a.mtime)) {
+      const m = meta(f.path);
+      if (m && !m.parent && m.cwd === cwd) return { sid: 'cx-' + m.id, id: m.id, cwd: m.cwd, how: 'newest' };
+    }
+    return null;
+  },
+};