@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/codex/records.ts

@@ -0,0 +1,114 @@
+// Facts about Codex rollout records shared by the reader and the writer. Checked against codex-rs at
+// rust-v0.147.0 (the version installed here) and the rollouts it wrote on this Mac; see
+// docs/sessions/2026-11-08-session-formats.md, entries 3 and 69.
+
+export const TOOL = "codex"
+export const LABEL = "Codex"
+
+/** Codex versions whose rollout format the writer was checked against. */
+export const TESTED_VERSIONS = ["0.147.0"]
+
+/**
+ * What Codex puts before the summary it writes at a compaction (core/src/compact.rs, templates/compact/summary_prefix.md at
+ * rust-v0.147.0, 399 bytes). Codex tells its own summaries apart by this text plus a newline, so the writer must use it exactly.
+ */
+export const SUMMARY_PREFIX = "Another language model started to solve this problem and produced a summary of its thinking process. You also have access to the state of the tools that were used by that language model. Use this to build on the work that has already been done and avoid duplicating work. Here is the summary produced by the other language model, use the information in this summary to assist with your own analysis:"
+
+/** The UI-only line Codex's own /import appends after imported history (external-agent-migration export.rs). */
+export const IMPORT_MARKER = "<EXTERNAL SESSION IMPORTED>"
+
+// Codex puts its own context into the history as user-role messages: AGENTS.md, the environment, aborted
+// turns, skills, hook prompts. Its TUI hides them (core/src/context/contextual_user_message.rs); so do we.
+// The list is Codex's own, not "anything in angle brackets", so a Claude Code message such as
+// <command-name>/clear</command-name> carried into Codex is still read back as the person's message.
+const CONTEXT_TAGS =
+  /^<(environment_context|environments?|user_instructions|turn_aborted|user_shell_command|subagent_notification|codex_internal_context|goal_context|recommended_plugins|skill|hook_prompt|external_[\w-]+)\b/
+const CONTEXT_PREFIXES = [
+  "# AGENTS.md instructions",
+  "Warning: apply_patch was requested via ",
+  "Warning: Your account was flagged for potentially high-risk cyber activity",
+  "Warning: The maximum number of unified exec processes you can keep open is",
+]
+
+/** Whether a user-role text part is Codex's injected context rather than something the person typed. */
+export function isContext(text: string): boolean {
+  const t = text.trim()
+  return CONTEXT_TAGS.test(t) || CONTEXT_PREFIXES.some((p) => t.startsWith(p))
+}
+
+/** The `<image name=[Image #1]>` / `</image>` labels Codex wraps around pasted images. */
+export const isImageLabel = (text: string) => /^<\/?image\b[^>]*>$/.test(text.trim())
+
+/**
+ * What Codex answers a call with when it was refused, failed before running, or was cut off: plain text
+ * with no exit code (core/src/tools/events.rs, tools/handlers/apply_patch.rs, context_manager/normalize.rs
+ * at rust-v0.147.0). Without this a rejected or unverified patch would read as a success.
+ */
+const FAILURE_TEXT = /^(?:aborted$|patch rejected|exec command rejected|apply_patch verification failed|apply_patch handler received|execution error:|failed to parse function arguments)/
+
+/**
+ * The text of a tool output and whether it succeeded. Codex serialises outputs as a string or a list of
+ * content items (FunctionCallOutputPayload); older rollouts wrote {content, success}. The exit status is
+ * only in the text: "Exit code: N" (shell), "Process exited with code N" (unified exec), or a JSON
+ * {output, metadata: {exit_code}} (older exec); refusals and errors are known by their wording.
+ */
+export function outputText(raw: unknown): { text: string; ok: boolean; images: number } {
+  if (raw && typeof raw === "object" && !Array.isArray(raw) && "content" in raw) {
+    const o = raw as { content: unknown; success?: unknown }
+    const inner = outputText(o.content)
+    return { ...inner, ok: o.success === false ? false : inner.ok }
+  }
+  let images = 0
+  let text: string
+  if (Array.isArray(raw)) {
+    const parts: string[] = []
+    for (const item of raw as Array<Record<string, unknown>>) {
+      if (typeof item?.text === "string") parts.push(item.text)
+      else if (item?.type === "input_image") images++
+    }
+    text = parts.join("\n")
+  } else if (typeof raw === "string") {
+    text = raw
+  } else {
+    text = raw === undefined || raw === null ? "" : JSON.stringify(raw)
+  }
+  let ok = true
+  if (text.startsWith("{") && text.includes('"exit_code"')) {
+    try {
+      const j = JSON.parse(text) as { output?: unknown; metadata?: { exit_code?: unknown } }
+      if (typeof j.metadata?.exit_code === "number") ok = j.metadata.exit_code === 0
+      if (typeof j.output === "string") text = j.output
+    } catch {
+      // not the JSON exec format after all; keep the text as it is
+    }
+  }
+  const code = text.slice(0, 400).match(/^(?:Exit code:|Process exited with code) (-?\d+)/m)
+  if (code) ok = code[1] === "0"
+  else if (FAILURE_TEXT.test(text.trim())) ok = false
+  return { text, ok, images }
+}
+
+/** The files an apply_patch touches, each with its own section of the patch. */
+export function patchFiles(patch: string): Array<{ path: string; patch: string }> {
+  const out: Array<{ path: string; lines: string[] }> = []
+  let cur: { path: string; lines: string[] } | undefined
+  for (const line of patch.split("\n")) {
+    const m = line.match(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/)
+    if (m) {
+      cur = { path: m[1]!.trim(), lines: [line] }
+      out.push(cur)
+    } else if (/^\*\*\* (Begin|End) Patch/.test(line)) {
+      cur = undefined
+    } else if (cur) {
+      cur.lines.push(line)
+    }
+  }
+  return out.map((f) => ({ path: f.path, patch: f.lines.join("\n") }))
+}
+
+/** The thread id in a rollout file name: rollout-YYYY-MM-DDThh-mm-ss-<uuid>.jsonl[.zst] or legacy rollout-<date>-<uuid>.json. */
+export function idFromName(path: string): string | undefined {
+  return path.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.json(?:l(?:\.zst)?)?$/i)?.[1]
+}
+
+export const isRolloutName = (name: string) => name.startsWith("rollout-") && /\.(jsonl|jsonl\.zst|json)$/.test(name)

package/src/adapters/codex/writer.ts

@@ -0,0 +1,479 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { exists, gitInfo, versionOf } from "../../fsutil.ts"
+import type { Project, Session, Turn } from "../../session/types.ts"
+import { toolLabel } from "../../brief.ts"
+import { imageDataUrl } from "../../session/attachments.ts"
+import { countTurns, firstUserText, isInjected, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { LABEL, TESTED_VERSIONS, TOOL, isContext, outputText } from "./records.ts"
+import { parseRollout } from "./reader.ts"
+import {
+  type Registration,
+  codexPatch,
+  compactedMessage,
+  displayChange,
+  execOutput,
+  itemTokens,
+  mcpParts,
+  patchCommand,
+  plainTitle,
+  patchOutput,
+  patchStdout,
+  registerThread,
+  replacementHistory,
+  userTextsOf,
+} from "./native.ts"
+
+// Continues a portable session in Codex as a new thread: a legacy-mode rollout written where Codex keeps
+// its own, shaped like the one Codex's /import builds (external-agent-migration rollout_items_from_messages,
+// and the session_meta that ThreadStore.create_thread writes with history_mode "legacy"). Unlike /import,
+// tool calls stay structural: function_call / function_call_output pairs (custom_tool_call for freeform
+// input such as apply_patch), with call ids remapped to Codex's call_ style.
+//
+// What the model is shown matches what a session Codex made itself would show it: shell calls are exec_command with
+// unified-exec output (which is also where a failed command's exit code lives), file edits are apply_patch run through
+// exec_command with the display events Codex keeps for them, a compaction carries the rebuilt history and Codex's
+// summary prefix so Codex does not replay it the legacy way, and the token count is Codex's own estimate of the
+// context rather than the size of everything ever said.
+//
+// No SQLite is written by this file. Once the rollout reads back, Codex's own app server is asked to read the thread
+// (`thread/read`), and Codex's read-repair adds it to state_5.sqlite, which is what the `codex resume` picker and
+// `--last` read first (tui/src/resume_picker.rs). If that step fails the thread still resumes by id.
+
+/** The installed Codex version ("codex-cli 0.147.0" → "0.147.0"), or undefined when Codex is missing. */
+export function codexVersion(): string | undefined {
+  return versionOf("codex")?.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/)?.[1]
+}
+
+/** The provider Codex will run with: the top-level model_provider in config.toml, else OpenAI. */
+function configuredProvider(home: string): string {
+  let text = ""
+  try {
+    text = readFileSync(join(home, ".codex", "config.toml"), "utf8")
+  } catch {
+    return "openai"
+  }
+  const top = text.split(/^\s*\[/m)[0] ?? ""
+  return top.match(/^\s*model_provider\s*=\s*["']([^"']+)["']/m)?.[1] ?? "openai"
+}
+
+const pad = (n: number) => String(n).padStart(2, "0")
+
+/** Where Codex would put a rollout started at `now`: local date folders and a local-time file name. */
+export function rolloutPath(home: string, id: string, now: Date): string {
+  const y = String(now.getFullYear())
+  const mo = pad(now.getMonth() + 1)
+  const d = pad(now.getDate())
+  const stamp = `${y}-${mo}-${d}T${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`
+  return join(home, ".codex", "sessions", y, mo, d, `rollout-${stamp}-${id}.jsonl`)
+}
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+const seconds = (at: string | undefined) => {
+  const t = at ? Date.parse(at) : Number.NaN
+  return Number.isFinite(t) ? Math.floor(t / 1000) : undefined
+}
+
+export interface RolloutPlan {
+  /** Every line of the rollout, in order. */
+  lines: Array<{ timestamp: string; type: string; payload: Record<string, unknown> }>
+  lost: string[]
+  /** What a read-back must find, to check the file. */
+  expect: { users: number; assistants: number; calls: number; failed: number }
+}
+
+
+/** The rollout lines for `session` as a new Codex thread `id`. Pure: writes nothing. */
+export function planRollout(
+  session: Session,
+  opts: { id: string; now: Date; cwd: string; cliVersion: string; modelProvider: string; git?: Omit<Project, "cwd">; newId?: () => string },
+): RolloutPlan {
+  const newId = opts.newId ?? (() => Bun.randomUUIDv7())
+  const lines: RolloutPlan["lines"] = []
+  // Each record is stamped with when the turn really happened (never going backwards); what has no time of its own
+  // takes the latest one. The thread itself is created now, like any fork.
+  const known = session.turns.map((t) => (t.at ? Date.parse(t.at) : Number.NaN)).find(Number.isFinite)
+  let clock = known ?? opts.now.getTime()
+  const stamp = (at?: string) => {
+    const t = at ? Date.parse(at) : Number.NaN
+    if (Number.isFinite(t) && t > clock) clock = t
+    return new Date(clock).toISOString()
+  }
+  const push = (type: string, payload: Record<string, unknown>, at?: string) => lines.push({ timestamp: stamp(at), type, payload })
+  const drops = new Map<string, number>()
+  const drop = (what: string, n = 1) => drops.set(what, (drops.get(what) ?? 0) + n)
+  const expect = { users: 0, assistants: 0, calls: 0, failed: 0 }
+  // Messages and calls written: reasoning and bookkeeping alone are not a conversation Codex can replay.
+  let replayed = 0
+  const cwd = opts.cwd
+
+  const git = opts.git ?? {}
+  // A compaction opens a new context window, as Codex's own do. The first window's id is in session_meta, as
+  // a real 0.144.4 capture has it, so a compaction's first_window_id points at something the file names.
+  const firstWindow = newId()
+  push("session_meta", {
+    id: opts.id,
+    session_id: opts.id,
+    timestamp: opts.now.toISOString(),
+    cwd,
+    originator: "codex-tui",
+    cli_version: opts.cliVersion,
+    source: "cli",
+    thread_source: "user",
+    model_provider: opts.modelProvider,
+    // None: Codex renders the instructions of whatever model resumes the thread.
+    base_instructions: null,
+    history_mode: "legacy",
+    context_window: { window_id: firstWindow },
+    ...(git.gitRemote || git.gitBranch || git.gitCommit
+      ? {
+          git: {
+            ...(git.gitCommit ? { commit_hash: git.gitCommit } : {}),
+            ...(git.gitBranch ? { branch: git.gitBranch } : {}),
+            ...(git.gitRemote ? { repository_url: git.gitRemote } : {}),
+          },
+        }
+      : {}),
+  })
+
+  // What the model will be shown, as Codex rebuilds it: for the token count, and for the history a compaction keeps.
+  let hist: Array<Record<string, any>> = []
+  const item = (payload: Record<string, any>, at?: string) => {
+    hist.push(payload)
+    push("response_item", payload, at)
+  }
+  let window = { number: 0, id: firstWindow }
+
+  // Codex turns open on a user message, as /import does; a session that starts mid-turn opens one silently.
+  let turnNo = 0
+  let open: { id: string; started?: number; last?: number } | undefined
+  const startTurn = (at: string | undefined) => {
+    closeTurn()
+    turnNo++
+    open = { id: `brain-import-turn-${turnNo}`, started: seconds(at) }
+    push("event_msg", { type: "task_started", turn_id: open.id, ...(open.started ? { started_at: open.started } : {}), model_context_window: null, collaboration_mode_kind: "default" }, at)
+  }
+  const ensureTurn = (at: string | undefined) => {
+    if (!open) startTurn(at)
+    const s = seconds(at)
+    if (s && open) open.last = s
+  }
+  const tokenCount = () => {
+    if (!open) return
+    const total = hist.reduce((n, h) => n + itemTokens(h), 0)
+    const usage = { input_tokens: 0, cached_input_tokens: 0, output_tokens: 0, reasoning_output_tokens: 0, total_tokens: total }
+    push("event_msg", { type: "token_count", info: { total_token_usage: usage, last_token_usage: usage, model_context_window: null }, rate_limits: null })
+  }
+  function closeTurn() {
+    if (!open) return
+    push("event_msg", {
+      type: "task_complete",
+      turn_id: open.id,
+      last_agent_message: null,
+      ...(open.started ? { started_at: open.started } : {}),
+      ...(open.last ? { completed_at: open.last } : {}),
+    })
+    open = undefined
+  }
+
+  // Call ids: Codex's are call_<alnum>. Others are mapped once, the same way for the call and its result.
+  const ids = new Map<string, string>()
+  const used = new Set<string>()
+  let remapped = 0
+  const callId = (id: string) => {
+    let v = ids.get(id)
+    if (v) return v
+    const base = /^call_[A-Za-z0-9_-]{1,60}$/.test(id) ? id : `call_${id.replace(/^[a-z]+_/, "").replace(/[^A-Za-z0-9]/g, "").slice(-40) || "x"}`
+    v = base
+    for (let n = 2; used.has(v); n++) v = `${base}_${n}`
+    ids.set(id, v)
+    used.add(v)
+    if (v !== id) remapped++
+    return v
+  }
+  // Function names must fit the Responses API's ^[A-Za-z0-9_-]{1,64}$.
+  let renamed = 0
+  const toolName = (name: string) => {
+    const v = name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 64) || "tool"
+    if (v !== name) renamed++
+    return v
+  }
+
+  // Which calls get a result later on, so the ones that never do can be closed where they stand; and the file
+  // edits each call made, which Codex records beside the call.
+  const answeredLater = new Set<number>()
+  const resultsAhead = new Set<string>()
+  const editsOf = new Map<string, Array<Extract<Turn, { kind: "file_edit" }>>>()
+  for (let i = session.turns.length - 1; i >= 0; i--) {
+    const t = session.turns[i]!
+    if (t.kind === "tool_result") resultsAhead.add(t.callId)
+    else if (t.kind === "tool_call" && resultsAhead.has(t.id)) answeredLater.add(i)
+    else if (t.kind === "file_edit" && t.callId && t.patch) editsOf.set(t.callId, [t, ...(editsOf.get(t.callId) ?? [])])
+  }
+
+  // How each written call is answered: a shell call with unified-exec output, an edit as the apply_patch it was,
+  // an MCP or web call with the event Codex shows for it, anything else as it came.
+  type Kind =
+    | { how: "shell" }
+    | { how: "patch"; patch: NonNullable<ReturnType<typeof codexPatch>> }
+    | { how: "mcp"; server: string; tool: string; args: unknown }
+    | { how: "web"; query: string }
+    | { how: "plain" }
+  const written = new Map<string, "function" | "custom">()
+  const kinds = new Map<string, Kind>()
+  const answered = new Set<string>()
+  const failedCalls = new Set<string>()
+  const output = (id: string, text: string, ok: boolean, at?: string) => {
+    const kind = kinds.get(id) ?? { how: "plain" }
+    let body = text
+    if (kind.how === "shell") body = execOutput(text, ok)
+    else if (kind.how === "patch") {
+      // The display record comes first, as Codex writes it.
+      push(
+        "event_msg",
+        {
+          type: "patch_apply_end",
+          call_id: callId(id),
+          turn_id: open?.id,
+          stdout: ok ? patchStdout(kind.patch.summary) : "",
+          stderr: ok ? "" : text,
+          success: ok,
+          changes: kind.patch.changes,
+          status: ok ? "completed" : "failed",
+        },
+        at,
+      )
+      body = ok ? patchOutput(kind.patch.summary) : `apply_patch verification failed: ${text}`
+    } else if (!ok && outputText(text).ok) {
+      // Codex stores no success flag, so a failure must say so in the text it reads back.
+      body = `execution error: ${text}`
+    }
+    if (!ok) {
+      failedCalls.add(id)
+      expect.failed++
+    }
+    item({ type: written.get(id) === "custom" ? "custom_tool_call_output" : "function_call_output", call_id: callId(id), output: body }, at)
+    if (kind.how === "mcp") {
+      push(
+        "event_msg",
+        {
+          type: "mcp_tool_call_end",
+          call_id: callId(id),
+          invocation: { server: kind.server, tool: kind.tool, arguments: kind.args },
+          duration: { secs: 0, nanos: 0 },
+          result: ok ? { Ok: { content: [{ type: "text", text }], isError: false } } : { Err: text },
+        },
+        at,
+      )
+    } else if (kind.how === "web") {
+      push("event_msg", { type: "web_search_end", call_id: callId(id), query: kind.query, action: { type: "search", query: kind.query } }, at)
+    }
+  }
+
+  for (const [i, t] of session.turns.entries()) {
+    switch (t.kind) {
+      case "user": {
+        const images: string[] = []
+        for (const a of t.attachments ?? []) {
+          const url = imageDataUrl(a)
+          if (url) images.push(url)
+          else drop("attachments")
+        }
+        if (!t.text.trim() && !images.length) break
+        startTurn(t.at)
+        replayed++
+        // Injected notices reach the model but are not the person's words: no history event for them.
+        if (!isInjected(t.text)) push("event_msg", { type: "user_message", message: t.text, images, local_images: [], local_audio: [], text_elements: [] }, t.at)
+        item({ type: "message", role: "user", content: [...(t.text.trim() ? [{ type: "input_text", text: t.text }] : []), ...images.map((image_url) => ({ type: "input_image", image_url }))] }, t.at)
+        if (!isContext(t.text)) expect.users++
+        break
+      }
+      case "assistant": {
+        if (!t.text.trim()) break
+        ensureTurn(t.at)
+        replayed++
+        push("event_msg", { type: "agent_message", message: t.text, phase: null, memory_citation: null }, t.at)
+        item({ type: "message", role: "assistant", content: [{ type: "output_text", text: t.text }] }, t.at)
+        expect.assistants++
+        break
+      }
+      case "tool_call": {
+        if (written.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        ensureTurn(t.at)
+        const input = t.input && typeof t.input === "object" && !Array.isArray(t.input) ? (t.input as Record<string, unknown>) : undefined
+        const command = typeof input?.command === "string" ? input.command : typeof input?.cmd === "string" ? input.cmd : undefined
+        const edited = editsOf.get(t.id)
+        const patch = (t.toolKind === "edit" || t.toolKind === "write") && edited ? codexPatch(edited.map((e) => ({ path: e.path, patch: e.patch! })), cwd) : undefined
+        let name = toolName(t.name)
+        let args: string | undefined
+        // A call already in Codex's own form (exec_command with cmd) is written as it was.
+        if (t.toolKind === "shell" && command !== undefined && t.name !== "exec_command") {
+          // What Codex's own model calls to run a command.
+          name = "exec_command"
+          args = JSON.stringify({ cmd: command, workdir: cwd })
+          kinds.set(t.id, { how: "shell" })
+        } else if (patch) {
+          // An edit is the apply_patch Codex intercepts when the model runs it through exec_command.
+          name = "exec_command"
+          args = JSON.stringify({ cmd: patchCommand(patch.text), workdir: cwd })
+          kinds.set(t.id, { how: "patch", patch })
+        } else if (mcpParts(t.name) && input) {
+          kinds.set(t.id, { how: "mcp", ...mcpParts(t.name)!, args: input })
+        } else if (/^web_?search$/i.test(t.name) && typeof input?.query === "string") {
+          kinds.set(t.id, { how: "web", query: input.query })
+        }
+        // Freeform input (Codex's apply_patch and other custom tools) stays freeform; anything else is JSON.
+        if (typeof t.input === "string") {
+          written.set(t.id, "custom")
+          item({ type: "custom_tool_call", status: "completed", call_id: callId(t.id), name, input: t.input }, t.at)
+        } else {
+          written.set(t.id, "function")
+          item({ type: "function_call", name, arguments: args ?? (JSON.stringify(t.input ?? {}) ?? "{}"), call_id: callId(t.id) }, t.at)
+        }
+        expect.calls++
+        replayed++
+        // The Responses API rejects a call with no output, so an unanswered call is closed here.
+        if (!answeredLater.has(i)) {
+          output(t.id, "(no result was recorded for this call)", true, t.at)
+          answered.add(t.id)
+          drop("tool calls without a result, closed with a placeholder")
+        }
+        break
+      }
+      case "tool_result": {
+        if (!written.has(t.callId)) {
+          drop("tool results without a call")
+          break
+        }
+        if (answered.has(t.callId)) {
+          drop("repeated tool results")
+          break
+        }
+        ensureTurn(t.at)
+        output(t.callId, t.output, t.ok, t.at)
+        answered.add(t.callId)
+        break
+      }
+      case "reasoning":
+        // Codex replays reasoning to the model only as its own (encrypted) items, so this is shown, not sent.
+        ensureTurn(t.at)
+        push("event_msg", { type: "agent_reasoning", text: t.text }, t.at)
+        break
+      case "compaction": {
+        ensureTurn(t.at)
+        const message = compactedMessage(t.summary)
+        const replacement = replacementHistory(userTextsOf(hist), message)
+        const previous = window.id
+        window = { number: window.number + 1, id: newId() }
+        push("compacted", { message, replacement_history: replacement, window_number: window.number, first_window_id: firstWindow, previous_window_id: previous, window_id: window.id }, t.at)
+        push("event_msg", { type: "context_compacted" }, t.at)
+        hist = [...replacement]
+        break
+      }
+      case "file_edit": {
+        // With a call id the edit travels as that call. One that could be written as an apply_patch already was, with
+        // its call; any other (a diff that was cut short, say) is kept as the record Codex shows for a change.
+        if (!t.callId) {
+          drop("file edits not made by a tool call")
+          break
+        }
+        if (kinds.get(t.callId)?.how === "patch") break
+        const shown = written.has(t.callId) && t.patch ? displayChange(t.patch, cwd, t.path) : undefined
+        if (!shown) {
+          drop("file edits Codex cannot show")
+          break
+        }
+        ensureTurn(t.at)
+        push("event_msg", { type: "patch_apply_end", call_id: callId(t.callId), turn_id: open?.id, stdout: "", stderr: "", success: true, changes: { [shown.path]: shown.change }, status: "completed" }, t.at)
+        break
+      }
+      case "subagent":
+        drop("subagent sessions")
+        break
+    }
+  }
+  if (!replayed) throw new Error("nothing Codex can replay: the session has no messages or tool calls")
+  // The importer closes with a token count so Codex knows how full the context is: Codex's own estimate of what it will send.
+  tokenCount()
+  closeTurn()
+
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  if (remapped) lost.push(`tool call ids, remapped to Codex call_ ids (${remapped})`)
+  if (renamed) lost.push(`tool names changed to fit Codex (${renamed})`)
+  return { lines, lost, expect }
+}
+
+/** How a thread gets into Codex's own index once its rollout is written; replaceable so tests never start Codex. */
+export type Register = (codexHome: string, threadId: string, cwd: string, name?: string) => Promise<Registration>
+
+/** The title the thread gets in Codex's picker: the session's own, marked with where it came from. */
+export const threadName = (session: Session) => `${plainTitle(session.header.title ?? firstUserText(session) ?? "Session")} (from ${toolLabel(session.header.tool)})`
+
+export function makeCodexWriter(register: Register = registerThread): Writer {
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(opts: WriteOptions): Promise<Readiness> {
+      const v = codexVersion()
+      if (!v) return { ok: false, why: "Codex is not installed here (`codex --version` failed)" }
+      if (!TESTED_VERSIONS.includes(v))
+        return { ok: false, why: `Codex ${v} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+      if (!exists(opts.cwd)) return { ok: false, why: `the folder to continue in does not exist: ${opts.cwd}` }
+      return { ok: true }
+    },
+
+    async write(session: Session, opts: WriteOptions): Promise<WriteResult> {
+      const now = new Date()
+      const id = Bun.randomUUIDv7()
+      const cwd = resolve(opts.cwd)
+      const plan = planRollout(session, {
+        id,
+        now,
+        cwd,
+        cliVersion: codexVersion() ?? TESTED_VERSIONS[0]!,
+        modelProvider: configuredProvider(opts.home),
+        git: gitInfo(cwd),
+      })
+      const path = rolloutPath(opts.home, id, now)
+      const lost = [...plan.lost]
+      if (!opts.dryRun) {
+        mkdirSync(dirname(path), { recursive: true })
+        // "wx": a new thread never replaces a file, even in the impossible case of an id clash.
+        writeFileSync(path, `${plan.lines.map((l) => JSON.stringify(l)).join("\n")}\n`, { flag: "wx" })
+        // Read it back as Codex's own rollouts are read; a file that does not round-trip is removed.
+        const back = parseRollout(readFileSync(path, "utf8"), path)
+        const n = countTurns(back)
+        const pairs = unpaired(back)
+        const failed = back.turns.filter((t) => t.kind === "tool_result" && !t.ok).length
+        if (n.user !== plan.expect.users || n.assistant !== plan.expect.assistants || n.tool_call !== plan.expect.calls || failed !== plan.expect.failed || pairs.calls.length || pairs.results.length) {
+          rmSync(path, { force: true })
+          throw new Error(
+            `the Codex rollout did not read back as written (users ${n.user}/${plan.expect.users}, replies ${n.assistant}/${plan.expect.assistants}, tool calls ${n.tool_call}/${plan.expect.calls}, failed results ${failed}/${plan.expect.failed}, unpaired ${pairs.calls.length + pairs.results.length}); nothing was kept`,
+          )
+        }
+        // Have Codex index the thread, so the picker and `--last` find it. If that fails the thread still resumes by id.
+        const registered = await register(join(opts.home, ".codex"), id, cwd, threadName(session))
+        if (!registered.ok) lost.push(`not in Codex's thread index (${registered.why}); it resumes by id, and appears in \`codex resume\` once opened`)
+        else if (registered.named === false) lost.push("thread title (Codex refused the name; the picker shows the first message instead)")
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId: id,
+        written: [path],
+        open: `cd ${shellQuote(cwd)} && codex resume ${id}`,
+        lost,
+        dryRun: !!opts.dryRun,
+      }
+    },
+  }
+}
+
+export const codexWriter: Writer = makeCodexWriter()

package/src/adapters/continue/index.ts

@@ -0,0 +1,9 @@
+import type { Reader, Writer } from "../types.ts"
+import { reader } from "./reader.ts"
+import { continueNativeWriter } from "./writer.ts"
+
+// Continue (VS Code and JetBrains extensions, and the cn CLI, which share ~/.continue/sessions): reads its
+// sessions, and continues any session as a new Continue chat in its history.
+export { reader }
+export const readers: Reader[] = [reader]
+export const writers: Writer[] = [continueNativeWriter]

package/src/adapters/continue/reader.ts

@@ -0,0 +1,68 @@
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+import { exists, mtime } from "../../fsutil.ts"
+import type { Session } from "../../session/types.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { CONTINUE, type Flavor, listPath, sessionsDir, toPortable, workspacePath } from "./records.ts"
+
+type Entry = { sessionId?: unknown; session_id?: unknown; title?: unknown; dateCreated?: unknown; workspaceDirectory?: unknown }
+
+/** The sessions.json list as Continue's HistoryManager.list reads it: an array, old-format entries skipped. */
+export function readList(home: string, f: Flavor): Entry[] {
+  const p = listPath(home, f)
+  if (!exists(p)) return []
+  let v: unknown
+  try {
+    v = JSON.parse(readFileSync(p, "utf8"))
+  } catch {
+    return []
+  }
+  return Array.isArray(v) ? v.filter((e): e is Entry => typeof e === "object" && e !== null && typeof (e as Entry).session_id !== "string") : []
+}
+
+/** A reader for Continue's session store, or PearAI's copy of it. */
+export function continueReader(f: Flavor): Reader {
+  return {
+    tool: f.tool,
+    label: f.label,
+
+    async list(home: string): Promise<SessionRef[]> {
+      const refs: SessionRef[] = []
+      for (const e of readList(home, f)) {
+        if (typeof e.sessionId !== "string" || !e.sessionId) continue
+        const path = join(sessionsDir(home, f), `${e.sessionId}.json`)
+        if (!exists(path)) continue
+        const cwd = workspacePath(e.workspaceDirectory)
+        const updatedAt = mtime(path)
+        refs.push({
+          tool: f.tool,
+          sourceId: e.sessionId,
+          path,
+          ...(typeof e.title === "string" ? { title: e.title } : {}),
+          ...(cwd ? { cwd } : {}),
+          ...(updatedAt ? { updatedAt } : {}),
+          ...(typeof e.dateCreated === "string" ? { extra: { dateCreated: e.dateCreated } } : {}),
+        })
+      }
+      return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+    },
+
+    async read(ref: SessionRef, home: string): Promise<Session> {
+      const path = ref.path || join(sessionsDir(home, f), `${ref.sourceId}.json`)
+      let raw: unknown
+      try {
+        raw = JSON.parse(readFileSync(path, "utf8"))
+      } catch (e) {
+        throw new Error(`cannot read ${f.label} session ${path}: ${(e as Error).message}`)
+      }
+      if (typeof raw !== "object" || raw === null || !Array.isArray((raw as { history?: unknown }).history)) throw new Error(`${path} is not a ${f.label} session (no history)`)
+      // HistoryManager.load trusts the file name over the id inside it.
+      const data = { ...(raw as Record<string, unknown>), sessionId: ref.sourceId }
+      const dateCreated = typeof ref.extra?.dateCreated === "string" ? ref.extra.dateCreated : undefined
+      const updated = mtime(path)
+      return toPortable(data, f, path, { ...(dateCreated ? { dateCreated } : {}), ...(updated ? { mtime: updated } : {}) })
+    },
+  }
+}
+
+export const reader = continueReader(CONTINUE)