0rrery 0.1.1 → 0.1.2

package/README.md

@@ -1,17 +1,17 @@
 # 0rrery
 
-Trace-first, local-first observability for AI agent workflows. Watch what your Claude Code sessions actually did — every tool call, subagent, LLM call, and permission decision — as live traces in a local dashboard. One process, one SQLite file, no cloud.
+Trace-first, local-first observability for AI agent workflows. Watch what your Claude Code sessions actually did (every tool call, subagent, LLM call, and permission decision) as live traces in a local dashboard. One process, one SQLite file, no cloud. Ingests Claude Code and OpenAI Codex CLI sessions.
 
 ## Quickstart
 
 ```
-bun install -g 0rrery
+npm install -g 0rrery    # or: bun install -g 0rrery
 0rrery init
 ```
 
 `init` does three things (each skippable): installs Claude Code hooks (`--no-hooks`), sets up a user service so 0rrery runs persistently (`--no-service`), and imports your existing session history (`--no-import`). Then open **http://localhost:7317**.
 
-Requires [Bun](https://bun.sh) ≥ 1.1. Claude Code hooks require the global install (the hook command is `0rrery hook`); `bunx 0rrery serve` works for a look around without installing.
+Requires [Bun](https://bun.sh) ≥ 1.1 at runtime: the CLI runs on Bun even when installed via npm, so `npm install` succeeds without Bun, but the `0rrery` command exits with an install-Bun message until Bun is on your PATH. Claude Code hooks require the global install (the hook command is `0rrery hook`); `bunx 0rrery serve` works for a look around without installing.
 
 ## Commands
 
@@ -52,7 +52,7 @@ Versions are published by CI via npm Trusted Publishing: bump the version in `sc
 ## Upgrade
 
 ```
-bun install -g 0rrery@latest
+npm install -g 0rrery@latest    # or: bun install -g 0rrery@latest
 0rrery service uninstall && 0rrery service install   # regenerate if the bin path changed
 ```
 
@@ -62,7 +62,7 @@ After upgrading (or when developing from the repo), rebuild and force a reinstal
 
 ```
 0rrery service uninstall
-bun remove -g 0rrery
+npm uninstall -g 0rrery    # or: bun remove -g 0rrery
 rm -rf ~/.0rrery
 ```
 Hook entries: re-run a Claude session or remove entries whose command is `0rrery hook` from `~/.claude/settings.json`.
@@ -78,3 +78,5 @@ bun run build:pkg    # stage the npm package in dist-pkg/
 ```
 
 Specs live in `docs/superpowers/specs/`.
+
+Want 0rrery to ingest another agent CLI? See [ADAPTERS.md](./ADAPTERS.md).

package/index.js

@@ -1,4 +1,6 @@
-#!/usr/bin/env bun
+#!/bin/sh
+':' //; command -v bun >/dev/null 2>&1 || { echo "0rrery runs on Bun (>= 1.1), and bun was not found on your PATH." >&2; echo "Install it from https://bun.sh then re-run this command." >&2; exit 1; }
+':' //; exec bun "$0" "$@"
 // @bun
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
@@ -16,9 +18,9 @@ var __export = (target, all) => {
 };
 
 // packages/cli/src/index.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7, openSync as openSync2, readSync as readSync2, closeSync as closeSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join8, resolve as resolve2 } from "path";
+import { join as join9, resolve as resolve2 } from "path";
 
 // packages/server/src/server.ts
 import { appendFileSync, mkdirSync } from "fs";
@@ -4009,7 +4011,7 @@ var ts = exports_external.number().int().nonnegative();
 var SessionStartSchema = exports_external.object({
   op: exports_external.literal("session.start"),
   sessionId: exports_external.string().min(1),
-  source: exports_external.enum(["claude-code", "api"]),
+  source: exports_external.enum(["claude-code", "api", "codex"]),
   project: exports_external.string().optional(),
   cwd: exports_external.string().optional(),
   gitBranch: exports_external.string().optional(),
@@ -5017,7 +5019,8 @@ function parseTranscriptLine(raw, state) {
 // packages/claude-code/src/importer.ts
 import { openSync, readSync, fstatSync, closeSync, readdirSync } from "fs";
 import { join as join3, dirname, basename } from "path";
-async function importTranscript(path, url, fromByte = 0, state = newTranscriptState(), finalize = false) {
+var claudeParser = { parse: parseTranscriptLine };
+async function importTranscript(path, url, fromByte = 0, state = newTranscriptState(), finalize = false, parser = claudeParser) {
   const fd = openSync(path, "r");
   let text;
   try {
@@ -5036,19 +5039,24 @@ async function importTranscript(path, url, fromByte = 0, state = newTranscriptSt
     return { ops: 0, emitted: true, bytesRead: fromByte };
   const complete = text.slice(0, lastNewline);
   const consumedBytes = Buffer.byteLength(text.slice(0, lastNewline + 1));
-  const snapshot = { ...state, agentToolUseIds: new Set(state.agentToolUseIds) };
+  const snapshot = { ...state };
+  for (const k of Object.keys(snapshot))
+    if (snapshot[k] instanceof Set)
+      snapshot[k] = new Set(snapshot[k]);
   const ops = complete.split(`
-`).filter(Boolean).flatMap((l) => parseTranscriptLine(l, state));
+`).filter(Boolean).flatMap((l) => parser.parse(l, state));
   if (ops.length > 0) {
     const maxTs = ops.reduce((max, o) => o.ts > max ? o.ts : max, 0);
-    if (state.agentId) {
+    if ("agentId" in state && state.agentId && ops.length) {
       ops.push({ op: "span.end", id: `agent:${state.agentId}`, ts: maxTs, status: "ok" });
     }
-    if (finalize && !state.agentId) {
+    if (finalize && !(("agentId" in state) && state.agentId)) {
       const sessionId = ops.find((o) => ("sessionId" in o))?.sessionId;
       if (sessionId)
         ops.push({ op: "session.end", sessionId, ts: maxTs });
     }
+    if (finalize && parser.finalize)
+      ops.push(...parser.finalize(state, maxTs));
   }
   const emitted = await emitOps(url, ops, 5000);
   if (!emitted) {
@@ -5058,23 +5066,27 @@ async function importTranscript(path, url, fromByte = 0, state = newTranscriptSt
   return { ops: ops.length, emitted, bytesRead: fromByte + consumedBytes };
 }
 async function importSession(path, url, opts = {}) {
+  const newState = opts.newState ?? newTranscriptState;
+  const parser = opts.parser ?? claudeParser;
   let files = 0, ops = 0, emitted = true;
-  const main = await importTranscript(path, url, 0, newTranscriptState(), opts.finalize ?? false);
+  const main = await importTranscript(path, url, 0, newState(), opts.finalize ?? false, parser);
   files++;
   ops += main.ops;
   emitted = emitted && main.emitted;
   if (!main.emitted)
     return { files, ops, emitted: false };
-  const subDir = join3(dirname(path), basename(path, ".jsonl"), "subagents");
-  let subs = [];
-  try {
-    subs = readdirSync(subDir).filter((f) => f.endsWith(".jsonl"));
-  } catch {}
-  for (const f of subs) {
-    const r = await importTranscript(join3(subDir, f), url, 0, newTranscriptState());
-    files++;
-    ops += r.ops;
-    emitted = emitted && r.emitted;
+  if (opts.parser === undefined) {
+    const subDir = join3(dirname(path), basename(path, ".jsonl"), "subagents");
+    let subs = [];
+    try {
+      subs = readdirSync(subDir).filter((f) => f.endsWith(".jsonl"));
+    } catch {}
+    for (const f of subs) {
+      const r = await importTranscript(join3(subDir, f), url, 0, newTranscriptState());
+      files++;
+      ops += r.ops;
+      emitted = emitted && r.emitted;
+    }
   }
   return { files, ops, emitted };
 }
@@ -5099,7 +5111,7 @@ function reviveState(json2) {
     agentToolUseIds: Array.isArray(j.agentToolUseIds) ? new Set(j.agentToolUseIds.filter((x) => typeof x === "string")) : fresh.agentToolUseIds
   };
 }
-function loadOffsets(path) {
+function loadOffsets(path, revive) {
   const out = new Map;
   let raw;
   try {
@@ -5115,7 +5127,7 @@ function loadOffsets(path) {
       if (!existsSync2(file))
         continue;
       const offset = Number.isInteger(entry?.offset) && entry.offset >= 0 ? entry.offset : 0;
-      out.set(file, { offset, state: reviveState(entry?.state) });
+      out.set(file, { offset, state: revive(entry?.state) });
     }
   } catch (e) {
     console.error("0rrery: tailer offsets snapshot corrupt, starting fresh", e);
@@ -5127,7 +5139,11 @@ function saveOffsets(path, files) {
   try {
     const filesJson = {};
     for (const [file, { offset, state }] of files) {
-      filesJson[file] = { offset, state: { ...state, agentToolUseIds: [...state.agentToolUseIds] } };
+      const serialized = { ...state };
+      for (const k of Object.keys(serialized))
+        if (serialized[k] instanceof Set)
+          serialized[k] = [...serialized[k]];
+      filesJson[file] = { offset, state: serialized };
     }
     writeFileSync(path + ".tmp", JSON.stringify({ version: VERSION, files: filesJson }));
     renameSync(path + ".tmp", path);
@@ -5138,7 +5154,7 @@ function saveOffsets(path, files) {
 
 // packages/claude-code/src/tailer.ts
 function startTailer(projectsDir, url, pollMs = 2000, offsetsPath) {
-  const files = offsetsPath ? loadOffsets(offsetsPath) : new Map;
+  const files = offsetsPath ? loadOffsets(offsetsPath, reviveState) : new Map;
   let stopped = false;
   let dirty = false;
   async function scanFile(path) {
@@ -5209,14 +5225,246 @@ function startTailer(projectsDir, url, pollMs = 2000, offsetsPath) {
     stopped = true;
   } };
 }
+// packages/codex/src/codex.ts
+function newCodexState() {
+  return { sessionId: null, project: null, model: null, openTurnId: null, turnIn: 0, turnOut: 0, threadId: null };
+}
+function reviveCodexState(json2) {
+  const fresh = newCodexState();
+  if (typeof json2 !== "object" || json2 === null)
+    return fresh;
+  const j = json2;
+  const str = (v) => typeof v === "string" ? v : null;
+  const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+  if (j.sessionId !== null && typeof j.sessionId !== "string")
+    return fresh;
+  return {
+    sessionId: str(j.sessionId),
+    project: str(j.project),
+    model: str(j.model),
+    openTurnId: str(j.openTurnId),
+    turnIn: num(j.turnIn),
+    turnOut: num(j.turnOut),
+    threadId: str(j.threadId)
+  };
+}
+function idSalt(state) {
+  return state.threadId !== null && state.threadId !== state.sessionId ? `:${state.threadId}` : "";
+}
+var preview = (s) => s.slice(0, 200);
+function messageText(content) {
+  if (!Array.isArray(content))
+    return "";
+  return content.map((c) => c?.text ?? "").join("").trim();
+}
+function parseCodexLine(raw, state) {
+  let line;
+  try {
+    line = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (typeof line !== "object" || line === null)
+    return [];
+  const parsed = Date.parse(line.timestamp);
+  const ts2 = Number.isNaN(parsed) ? Date.now() : parsed;
+  const p = line.payload;
+  if (typeof p !== "object" || p === null)
+    return [];
+  if (line.type === "session_meta") {
+    state.sessionId = typeof p.session_id === "string" ? p.session_id : typeof p.id === "string" ? p.id : null;
+    if (!state.sessionId)
+      return [];
+    state.threadId = typeof p.id === "string" ? p.id : state.sessionId;
+    state.project = typeof p.cwd === "string" ? p.cwd.split("/").pop() ?? null : null;
+    state.model = typeof p.model_provider === "string" ? p.model_provider : null;
+    return [{
+      op: "session.start",
+      sessionId: state.sessionId,
+      source: "codex",
+      ts: ts2,
+      project: state.project ?? undefined,
+      cwd: typeof p.cwd === "string" ? p.cwd : undefined,
+      meta: { model_provider: p.model_provider, cli_version: p.cli_version, originator: p.originator }
+    }];
+  }
+  const sid = state.sessionId;
+  if (!sid)
+    return [];
+  const ops = [];
+  const closeTurn = (endTs) => {
+    if (!state.openTurnId)
+      return;
+    ops.push({ op: "span.end", id: `llm:${state.openTurnId}`, ts: endTs, status: "ok" });
+    state.openTurnId = null;
+    state.turnIn = 0;
+    state.turnOut = 0;
+  };
+  if (line.type === "turn_context") {
+    closeTurn(ts2);
+    const turnId = typeof p.turn_id === "string" ? p.turn_id : null;
+    if (typeof p.model === "string")
+      state.model = p.model;
+    if (turnId) {
+      state.openTurnId = turnId;
+      ops.push({
+        op: "span.start",
+        id: `llm:${turnId}`,
+        sessionId: sid,
+        parentId: null,
+        kind: "llm",
+        name: state.model ?? "(model)",
+        ts: ts2,
+        attrs: {}
+      });
+      ops.push({ op: "event", id: `evt:turn:${turnId}`, sessionId: sid, type: "turn.context", ts: ts2, attrs: {} });
+    }
+    return ops;
+  }
+  if (line.type === "event_msg") {
+    if (p.type === "task_complete") {
+      closeTurn(ts2);
+      ops.push({ op: "event", id: `evt:stop:${sid}${idSalt(state)}:${ts2}`, sessionId: sid, type: "turn.stop", ts: ts2, attrs: {} });
+      return ops;
+    }
+    if (p.type === "token_count" && p.info && typeof p.info === "object" && state.openTurnId) {
+      const u = p.info.last_token_usage;
+      if (u && typeof u === "object") {
+        state.turnIn += u.input_tokens ?? 0;
+        state.turnOut += u.output_tokens ?? 0;
+        ops.push({
+          op: "span.start",
+          id: `llm:${state.openTurnId}`,
+          sessionId: sid,
+          parentId: null,
+          kind: "llm",
+          name: state.model ?? "(model)",
+          ts: ts2,
+          attrs: { input_tokens: state.turnIn, output_tokens: state.turnOut }
+        });
+      }
+      return ops;
+    }
+    return [];
+  }
+  if (line.type === "response_item") {
+    if (p.type === "function_call" && typeof p.call_id === "string") {
+      let input = p.arguments;
+      try {
+        input = JSON.parse(p.arguments);
+      } catch {}
+      const name = typeof p.name === "string" ? p.name : "(tool)";
+      return [{
+        op: "span.start",
+        id: `tool:${p.call_id}`,
+        sessionId: sid,
+        parentId: state.openTurnId ? `llm:${state.openTurnId}` : null,
+        kind: isMcpTool(name) ? "mcp" : "tool",
+        name,
+        ts: ts2,
+        attrs: { input }
+      }];
+    }
+    if (p.type === "function_call_output" && typeof p.call_id === "string") {
+      const out = typeof p.output === "string" ? p.output : "";
+      const status = /exited with code [1-9]/.test(out) ? "error" : "ok";
+      return [{ op: "span.end", id: `tool:${p.call_id}`, ts: ts2, status, attrs: {} }];
+    }
+    if (p.type === "web_search_call" && typeof p.id === "string") {
+      return [
+        {
+          op: "span.start",
+          id: `tool:${p.id}`,
+          sessionId: sid,
+          parentId: state.openTurnId ? `llm:${state.openTurnId}` : null,
+          kind: "tool",
+          name: "web_search",
+          ts: ts2,
+          attrs: { input: { query: p.action?.query ?? "" } }
+        },
+        { op: "span.end", id: `tool:${p.id}`, ts: ts2, status: "ok", attrs: {} }
+      ];
+    }
+    if (p.type === "message" && (p.role === "user" || p.role === "assistant")) {
+      const text = messageText(p.content);
+      if (!text)
+        return [];
+      return [{
+        op: "event",
+        id: `evt:msg:${sid}${idSalt(state)}:${ts2}:${p.role}`,
+        sessionId: sid,
+        type: p.role === "user" ? "message.user" : "message.assistant",
+        ts: ts2,
+        attrs: { preview: preview(text) }
+      }];
+    }
+    return [];
+  }
+  return [];
+}
+var codexParser = {
+  parse: parseCodexLine,
+  finalize: (state, maxTs) => state.openTurnId ? [{ op: "span.end", id: `llm:${state.openTurnId}`, ts: maxTs, status: "ok" }] : []
+};
+// packages/codex/src/tailer.ts
+import { readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join5 } from "path";
+function startCodexTailer(rootDir, url, pollMs = 2000, offsetsPath) {
+  const files = offsetsPath ? loadOffsets(offsetsPath, reviveCodexState) : new Map;
+  let stopped = false;
+  const pass = async () => {
+    let dirty = false;
+    let entries = [];
+    try {
+      entries = readdirSync3(rootDir, { recursive: true }).filter((e) => e.endsWith(".jsonl"));
+    } catch {
+      return;
+    }
+    for (const rel of entries) {
+      const path = join5(rootDir, String(rel));
+      try {
+        let fs = files.get(path);
+        if (!fs) {
+          fs = { offset: 0, state: newCodexState() };
+          files.set(path, fs);
+        }
+        const size = statSync2(path).size;
+        if (size < fs.offset) {
+          fs.offset = 0;
+          fs.state = newCodexState();
+          dirty = true;
+        }
+        if (size > fs.offset) {
+          const r = await importTranscript(path, url, fs.offset, fs.state, false, codexParser);
+          if (r.bytesRead !== fs.offset) {
+            fs.offset = r.bytesRead;
+            dirty = true;
+          }
+        }
+      } catch {}
+    }
+    if (dirty && offsetsPath)
+      saveOffsets(offsetsPath, files);
+  };
+  const loop = async () => {
+    while (!stopped) {
+      await pass();
+      await Bun.sleep(pollMs);
+    }
+  };
+  loop();
+  return { stop() {
+    stopped = true;
+  } };
+}
 // packages/cli/src/install.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var HOOK_EVENTS = ["SessionStart", "SessionEnd", "PreToolUse", "PostToolUse", "Notification", "Stop", "SubagentStop", "PermissionRequest", "PermissionDenied"];
 var NEEDS_MATCHER = new Set(["PreToolUse", "PostToolUse"]);
 function installHooks(claudeDir, hookCommand) {
   mkdirSync2(claudeDir, { recursive: true });
-  const settingsPath = join5(claudeDir, "settings.json");
+  const settingsPath = join6(claudeDir, "settings.json");
   let settings = {};
   if (existsSync3(settingsPath)) {
     try {
@@ -5248,34 +5496,58 @@ function installHooks(claudeDir, hookCommand) {
 }
 
 // packages/cli/src/sweep.ts
-async function importAll(projectsDir, url) {
-  const files = Array.from(new Bun.Glob("*/*.jsonl").scanSync({ cwd: projectsDir, absolute: true })).sort();
+import { existsSync as existsSync4 } from "fs";
+async function importOne(path, url, opts, label) {
+  try {
+    const r = await importSession(path, url, opts);
+    if (r.emitted) {
+      console.log(`  ${label}: ${r.ops} ops`);
+      return "ok";
+    }
+    console.error(`  ${label}: server unreachable at ${url} \u2014 aborting sweep`);
+    return "unreachable";
+  } catch (err) {
+    console.error(`  ${label}: ${err instanceof Error ? err.message : String(err)}`);
+    return "failed";
+  }
+}
+async function importAll(projectsDir, url, codexRoot) {
+  const claudeFiles = existsSync4(projectsDir) ? Array.from(new Bun.Glob("*/*.jsonl").scanSync({ cwd: projectsDir, absolute: true })).sort() : [];
   let ok = 0;
   let failed = 0;
-  for (const f of files) {
+  let aborted = false;
+  for (const f of claudeFiles) {
     const name = f.split("/").slice(-2).join("/");
-    try {
-      const r = await importSession(f, url, { finalize: true });
-      if (r.emitted) {
-        ok++;
-        console.log(`  ${name}: ${r.ops} ops`);
-      } else {
-        failed++;
-        console.error(`  ${name}: server unreachable at ${url} \u2014 aborting sweep`);
+    const result = await importOne(f, url, { finalize: true }, name);
+    if (result === "ok") {
+      ok++;
+    } else {
+      failed++;
+      if (result === "unreachable") {
+        aborted = true;
         break;
       }
-    } catch (err) {
+    }
+  }
+  const codexFiles = !aborted && codexRoot && existsSync4(codexRoot) ? Array.from(new Bun.Glob("**/*.jsonl").scanSync({ cwd: codexRoot, absolute: true })).sort() : [];
+  for (const f of codexFiles) {
+    const name = f.split("/").slice(-2).join("/");
+    const result = await importOne(f, url, { finalize: true, parser: codexParser, newState: newCodexState }, name);
+    if (result === "ok") {
+      ok++;
+    } else {
       failed++;
-      console.error(`  ${name}: ${err instanceof Error ? err.message : String(err)}`);
+      if (result === "unreachable")
+        break;
     }
   }
-  return { ok, failed, total: files.length };
+  return { ok, failed, total: claudeFiles.length + codexFiles.length };
 }
 
 // packages/cli/src/service.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, realpathSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, realpathSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname2, join as join7 } from "path";
 function systemdUnit(execStart) {
   return `[Unit]
 Description=0rrery - trace-first observability for AI agent workflows
@@ -5309,9 +5581,9 @@ ${items}
 }
 function servicePath(platform = process.platform) {
   if (platform === "linux")
-    return join6(homedir2(), ".config/systemd/user/0rrery.service");
+    return join7(homedir2(), ".config/systemd/user/0rrery.service");
   if (platform === "darwin")
-    return join6(homedir2(), "Library/LaunchAgents/com.0pon.0rrery.plist");
+    return join7(homedir2(), "Library/LaunchAgents/com.0pon.0rrery.plist");
   return null;
 }
 function resolveBin() {
@@ -5331,7 +5603,7 @@ function runService(sub, platform = process.platform, exec = run, file = service
   const linux = platform === "linux";
   if (sub === "install") {
     const bin = resolveBin();
-    if (!linux && existsSync4(file))
+    if (!linux && existsSync5(file))
       exec(["launchctl", "unload", "-w", file]);
     mkdirSync3(dirname2(file), { recursive: true });
     writeFileSync3(file, linux ? systemdUnit([...bin, "serve"].join(" ")) : launchdPlist([...bin, "serve"]));
@@ -5340,7 +5612,7 @@ function runService(sub, platform = process.platform, exec = run, file = service
     return ok;
   }
   if (sub === "uninstall") {
-    const existed = existsSync4(file);
+    const existed = existsSync5(file);
     const ok = linux ? exec(["systemctl", "--user", "disable", "--now", "0rrery"]) : exec(["launchctl", "unload", "-w", file]);
     if (!existed) {
       console.log("no service installed");
@@ -5362,14 +5634,14 @@ function runService(sub, platform = process.platform, exec = run, file = service
 }
 
 // packages/cli/src/skill.ts
-import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync4 } from "fs";
-import { join as join7 } from "path";
+import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { join as join8 } from "path";
 function skillSourceDir() {
-  const candidates = [join7(import.meta.dir, "skill"), join7(import.meta.dir, "../skill")];
-  return candidates.find(existsSync5) ?? null;
+  const candidates = [join8(import.meta.dir, "skill"), join8(import.meta.dir, "../skill")];
+  return candidates.find(existsSync6) ?? null;
 }
 function installSkill(claudeDir, srcDir) {
-  const dest = join7(claudeDir, "skills", "0rrery");
+  const dest = join8(claudeDir, "skills", "0rrery");
   mkdirSync4(dest, { recursive: true });
   cpSync(srcDir, dest, { recursive: true });
   return dest;
@@ -5378,9 +5650,20 @@ function installSkill(claudeDir, srcDir) {
 // packages/cli/src/index.ts
 var [cmd, arg] = process.argv.slice(2);
 var url = process.env.ORRERY_URL ?? "http://localhost:7317";
-var claudeDir = () => process.env.ORRERY_CLAUDE_DIR ?? join8(homedir3(), ".claude");
+var claudeDir = () => process.env.ORRERY_CLAUDE_DIR ?? join9(homedir3(), ".claude");
+var codexDir = () => process.env.ORRERY_CODEX_DIR ?? join9(homedir3(), ".codex", "sessions");
+function sniffHead(path) {
+  const fd = openSync2(path, "r");
+  try {
+    const buf = Buffer.alloc(400);
+    const n = readSync2(fd, buf, 0, buf.length, 0);
+    return buf.subarray(0, n).toString("utf8");
+  } finally {
+    closeSync2(fd);
+  }
+}
 function runInstall() {
-  if (!existsSync6(claudeDir())) {
+  if (!existsSync7(claudeDir())) {
     console.warn(`${claudeDir()} not found \u2014 Claude Code not present, skipping hooks`);
     return false;
   }
@@ -5397,12 +5680,16 @@ switch (cmd) {
   case "serve": {
     const config = loadConfig();
     const srv = startServer(config);
-    const projectsDir = join8(claudeDir(), "projects");
-    const tailer = startTailer(projectsDir, srv.url, 2000, join8(config.dataDir, "tailer-offsets.json"));
+    const projectsDir = join9(claudeDir(), "projects");
+    const tailer = startTailer(projectsDir, srv.url, 2000, join9(config.dataDir, "tailer-offsets.json"));
+    const cx = existsSync7(codexDir()) ? startCodexTailer(codexDir(), srv.url, 2000, join9(config.dataDir, "codex-offsets.json")) : null;
     console.log(`0rrery serving on ${srv.url} (db: ${config.dbPath})`);
     console.log(`tailing ${projectsDir}`);
+    if (cx)
+      console.log(`tailing ${codexDir()} (codex)`);
     process.on("SIGINT", () => {
       tailer.stop();
+      cx?.stop();
       srv.stop();
       process.exit(0);
     });
@@ -5431,15 +5718,18 @@ switch (cmd) {
       process.exit(1);
     }
     if (arg === "--all") {
-      const projectsDir = join8(claudeDir(), "projects");
-      const r2 = await importAll(projectsDir, url);
+      const projectsDir = join9(claudeDir(), "projects");
+      const cxRoot = existsSync7(codexDir()) ? codexDir() : undefined;
+      const r2 = await importAll(projectsDir, url, cxRoot);
       console.log(r2.total ? `imported ${r2.ok}/${r2.total} transcript(s)` : `no transcripts found under ${projectsDir}`);
       process.exit(r2.failed && !r2.ok ? 1 : 0);
       break;
     }
     let r;
     try {
-      r = await importSession(resolve2(arg), url, { finalize: true });
+      const path = resolve2(arg);
+      const isCodex = /"type"\s*:\s*"session_meta"/.test(sniffHead(path));
+      r = isCodex ? await importSession(path, url, { finalize: true, parser: codexParser, newState: newCodexState }) : await importSession(path, url, { finalize: true });
     } catch (err) {
       console.error(`0rrery import: cannot read ${arg}: ${err instanceof Error ? err.message : String(err)}`);
       process.exit(1);
@@ -5472,7 +5762,7 @@ switch (cmd) {
     if (!flags.has("--no-skill")) {
       console.log("\u203A skill");
       const src = skillSourceDir();
-      if (!existsSync6(claudeDir()))
+      if (!existsSync7(claudeDir()))
         console.log(`  ${claudeDir()} not found \u2014 skipping skill`);
       else if (!src)
         console.log("  skill assets not found \u2014 skipping");
@@ -5486,14 +5776,15 @@ switch (cmd) {
     }
     if (!flags.has("--no-import")) {
       console.log("\u203A importing history");
-      const projectsDir = join8(claudeDir(), "projects");
-      if (existsSync6(projectsDir)) {
+      const projectsDir = join9(claudeDir(), "projects");
+      const cxRoot = existsSync7(codexDir()) ? codexDir() : undefined;
+      if (existsSync7(projectsDir) || cxRoot) {
         for (let i = 0;i < 30; i++) {
           if (await fetch(`${url}/api/sessions`).then((x) => x.ok).catch(() => false))
             break;
           await Bun.sleep(200);
         }
-        const r = await importAll(projectsDir, url);
+        const r = await importAll(projectsDir, url, cxRoot);
         console.log(r.total ? `  imported ${r.ok}/${r.total} transcript(s)` : "  no transcripts found");
       } else {
         console.log(`  ${projectsDir} not found \u2014 nothing to import`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0rrery",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Trace-first, local-first observability for AI agent workflows",
   "license": "MIT",
   "repository": {

package/skill/SKILL.md

@@ -5,7 +5,7 @@ description: Use when the user asks about past agent sessions, AI spend/cost, to
 
 # 0rrery — query your own trace history
 
-0rrery records every Claude Code session on this machine (tools, subagents, LLM calls, permissions) in a local SQLite DB behind a localhost HTTP API. Use it to answer questions about past sessions, spend, failures, and agent activity.
+0rrery records every Claude Code and Codex CLI session on this machine (tools, subagents, LLM calls, permissions) in a local SQLite DB behind a localhost HTTP API. Use it to answer questions about past sessions, spend, failures, and agent activity.
 
 ## Before anything: is it running?