@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/gemini-cli/exchanges.ts

@@ -0,0 +1,228 @@
+import { readFileSync, realpathSync, statSync } from "node:fs"
+import { extname, resolve } from "node:path"
+import type { Attachment, Session, Turn, Usage } from "../../session/types.ts"
+
+// What the Gemini family's writers (Gemini CLI, and its forks Qwen Code and iFlow CLI) share: the portable
+// session's flat turns regrouped into the exchanges these tools keep (a person's message; one model
+// response with its readable thoughts, its text and its tool calls, each with the result and edits that
+// answered it; a compaction summary), and portable tool calls mapped onto a target's own tools.
+
+export type Call = Extract<Turn, { kind: "tool_call" }>
+export type Result = Extract<Turn, { kind: "tool_result" }>
+export type Edit = Extract<Turn, { kind: "file_edit" }>
+
+export interface Answered {
+  call: Call
+  /** Undefined when the session never recorded one; writers close the call as failed. */
+  result?: Result
+  edits: Edit[]
+}
+
+export type Exchange =
+  | { kind: "user"; at?: string; text: string; attachments: Attachment[] }
+  | { kind: "model"; at?: string; model?: string; usage?: Usage; thoughts: Array<{ at?: string; text: string }>; text: string; calls: Answered[] }
+  | { kind: "compaction"; at?: string; summary: string }
+
+export type Drop = (what: string, n?: number) => void
+
+/** Counts what a writer drops, by phrase, and lists it the way `WriteResult.lost` wants. */
+export function drops() {
+  const counts = new Map<string, number>()
+  const drop: Drop = (what, n = 1) => counts.set(what, (counts.get(what) ?? 0) + n)
+  return { drop, list: () => [...counts].map(([what, n]) => `${what} (${n})`) }
+}
+
+/**
+ * The session's exchanges, in order. A tool result closes the response that made its call, so a call made
+ * after it starts a new response, as it does in these tools (the model saw the result before calling
+ * again). With `fromLastCompaction`, a compacted session starts from its last summary, the way a tool that
+ * replaces the history with its summary would load it; the turns before it are dropped and counted.
+ */
+export function regroup(session: Session, opts: { fromLastCompaction: boolean; keepReasoning: boolean; drop: Drop }): Exchange[] {
+  const { drop } = opts
+  let turns = session.turns
+  if (opts.fromLastCompaction) {
+    let last = -1
+    turns.forEach((t, i) => {
+      if (t.kind === "compaction") last = i
+    })
+    if (last > 0) {
+      drop("turns before the last compaction, which its summary replaced", last)
+      turns = turns.slice(last)
+    }
+  }
+  const out: Exchange[] = []
+  type Model = Extract<Exchange, { kind: "model" }>
+  let cur: Model | undefined
+  const answered = new Map<string, Answered>()
+  const flush = () => {
+    if (cur && (cur.text.trim() || cur.calls.length || cur.thoughts.length)) out.push(cur)
+    cur = undefined
+  }
+  const model = (at: string | undefined) => (cur ??= { kind: "model", ...(at ? { at } : {}), thoughts: [], text: "", calls: [] })
+  for (const t of turns) {
+    switch (t.kind) {
+      case "user":
+        flush()
+        if (t.text.trim() || t.attachments?.length) out.push({ kind: "user", ...(t.at ? { at: t.at } : {}), text: t.text, attachments: t.attachments ?? [] })
+        break
+      case "compaction":
+        flush()
+        out.push({ kind: "compaction", ...(t.at ? { at: t.at } : {}), summary: t.summary })
+        break
+      case "reasoning":
+        if (!opts.keepReasoning) {
+          drop("reasoning (no place for it)")
+          break
+        }
+        // Thinking comes before a response's text and calls; thinking after them starts the next response.
+        if (cur && (cur.text || cur.calls.length)) flush()
+        if (t.text.trim()) model(t.at).thoughts.push({ ...(t.at ? { at: t.at } : {}), text: t.text })
+        break
+      case "assistant": {
+        // Text after a tool call was written once the call's result came back: a new response.
+        if (cur?.calls.length) flush()
+        if (!t.text.trim()) break
+        const m = model(t.at)
+        m.text = m.text ? `${m.text}\n\n${t.text}` : t.text
+        if (t.model && !m.model) m.model = t.model
+        if (t.usage && !m.usage) m.usage = t.usage
+        break
+      }
+      case "tool_call": {
+        if (answered.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        const a: Answered = { call: t, edits: [] }
+        answered.set(t.id, a)
+        model(t.at).calls.push(a)
+        break
+      }
+      case "tool_result": {
+        const a = answered.get(t.callId)
+        if (!a) drop("tool results without a call")
+        else if (a.result) drop("repeated tool results")
+        else {
+          a.result = t
+          if (cur?.calls.includes(a)) flush()
+        }
+        break
+      }
+      case "file_edit": {
+        const a = t.callId ? answered.get(t.callId) : undefined
+        if (a) a.edits.push(t)
+        else drop("file edits not made by a tool call")
+        break
+      }
+      case "subagent":
+        drop("subagent sessions (their results stay in the parent's tool results)")
+        break
+    }
+  }
+  flush()
+  return out
+}
+
+/** A target tool: its name, and for each argument it takes, the names other tools give that argument. */
+export interface ToolSpec {
+  name: string
+  /** The first argument is the one the call must have for the mapping to apply. */
+  args: Record<string, readonly string[]>
+}
+
+export const ALIASES = {
+  file: ["file_path", "path", "filePath", "absolute_path", "target_file", "file", "filename", "notebook_path"],
+  dir: ["dir_path", "path", "directory", "relative_workspace_path", "target_directory", "dir"],
+  oldText: ["old_string", "oldString", "old_str", "old_text"],
+  newText: ["new_string", "newString", "new_str", "new_text"],
+  content: ["content", "contents", "file_text", "text"],
+  command: ["command", "cmd", "commandLine"],
+  pattern: ["pattern", "query", "regex", "search", "glob_pattern"],
+  query: ["query", "search_term", "q"],
+  url: ["url", "uri"],
+} as const
+
+/** Function names Gemini, OpenAI-style APIs and these tools all accept. */
+export const functionName = (name: string) => {
+  const v = name.replace(/[^A-Za-z0-9_.:-]/g, "_").slice(0, 64)
+  return /^[A-Za-z_]/.test(v) ? v : `_${v}`.slice(0, 64)
+}
+
+/**
+ * A portable call as the target's own tool: the target's name and argument names, with every argument the
+ * target has no name for kept as it was. A call whose main argument cannot be found keeps its own name and
+ * arguments, so nothing is guessed. Arguments must be an object; anything else is wrapped as {input}.
+ */
+export function mapCall(call: Call, spec: ToolSpec | undefined): { name: string; args: Record<string, unknown> } {
+  const input = call.input && typeof call.input === "object" && !Array.isArray(call.input) ? (call.input as Record<string, unknown>) : undefined
+  const own = { name: functionName(call.name), args: input ?? { input: call.input ?? null } }
+  if (!spec || !input) return own
+  const keys = Object.entries(spec.args)
+  const found = (aliases: readonly string[]) => aliases.find((k) => input[k] !== undefined && input[k] !== null)
+  if (!keys.length || !found(keys[0]![1])) return own
+  const args: Record<string, unknown> = {}
+  const used = new Set<string>()
+  for (const [key, aliases] of keys) {
+    const from = aliases.filter((k) => !used.has(k)).find((k) => input[k] !== undefined && input[k] !== null)
+    if (!from) continue
+    used.add(from)
+    const v = input[from]
+    // A command given as argv (Codex's shell) is one command line to these tools.
+    args[key] = key === "command" && Array.isArray(v) && v.every((x) => typeof x === "string") ? v.join(" ") : v
+  }
+  for (const [k, v] of Object.entries(input)) if (!used.has(k) && !(k in args)) args[k] = v
+  return { name: spec.name, args }
+}
+
+const IMAGE_TYPES: Record<string, string> = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" }
+const IMAGE_LIMIT = 5 * 1024 * 1024
+
+/** An attached image's bytes, when it is still on disk, a known image type, and small enough to inline. */
+export function imageData(a: Attachment): { mimeType: string; data: string } | undefined {
+  if (a.kind !== "image" || !a.path) return undefined
+  const mimeType = a.mime ?? IMAGE_TYPES[extname(a.path).toLowerCase()]
+  if (!mimeType || !Object.values(IMAGE_TYPES).includes(mimeType)) return undefined
+  try {
+    if (statSync(a.path).size > IMAGE_LIMIT) return undefined
+    return { mimeType, data: readFileSync(a.path).toString("base64") }
+  } catch {
+    return undefined
+  }
+}
+
+/** The text a tool result carries into the target, with where its full output was kept when it was cut. */
+export function resultOutput(r: Result | undefined): string {
+  if (!r) return "(no result was recorded for this call)"
+  const out = r.fullPath ? `${r.output}\n\n[Full output: ${r.fullPath}]` : r.output
+  return out.trim() ? out : "(no output)"
+}
+
+/** Timestamps that never go backwards, from the turns' own times where they have them. */
+export function clock(session: Session, now: Date) {
+  const known = session.turns.map((t) => (t.at ? Date.parse(t.at) : Number.NaN)).find(Number.isFinite)
+  let t = (known ?? now.getTime()) - 1
+  return (at?: string) => {
+    const v = at ? Date.parse(at) : Number.NaN
+    t = Number.isFinite(v) && v > t ? v : t + 1
+    return new Date(t).toISOString()
+  }
+}
+
+/** A one-line title for the new session: the source's title, or its first request. */
+export function titleOf(session: Session): string {
+  const first = session.turns.find((t) => t.kind === "user" && t.text.trim()) as Extract<Turn, { kind: "user" }> | undefined
+  return (session.header.title ?? first?.text ?? "Session").replace(/\s+/g, " ").trim().slice(0, 80) || "Session"
+}
+
+/** A folder as these tools record it: the resolved path the process sees (/tmp is /private/tmp on macOS). */
+export function realCwd(cwd: string): string {
+  try {
+    return realpathSync(cwd)
+  } catch {
+    return resolve(cwd)
+  }
+}
+
+/** A word for a shell command line, quoted only when it needs it. */
+export const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)

package/src/adapters/gemini-cli/index.ts

@@ -0,0 +1,396 @@
+import { createHash } from "node:crypto"
+import { readFileSync } from "node:fs"
+import { basename, dirname, join } from "node:path"
+import { gitInfo, isDir, ls, mtime, readJson } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { header, iso, lossCounter } from "../../session/util.ts"
+import type { Reader, SessionRef, Writer } from "../types.ts"
+import { closeOpenCalls, CONTINUED_NOTE, type Conversation, ignoredUserContent, LABEL, loadConversation, messagesToTurns, newCtx, type Part, partsToTurns, TOOL, toParts } from "./records.ts"
+import { geminiNativeWriter } from "./writer.ts"
+
+// Gemini CLI keeps each project's sessions under ~/.gemini/tmp/<project>/: chats/session-*.json (0.33 and
+// older: one JSON document rewritten every turn) or chats/session-*.jsonl (current: an append-only log),
+// subagent sessions in chats/<parent session id>/<id>.jsonl, and, when checkpointing is on,
+// checkpoints/*.json snapshots of the API history taken before each file edit. Versions before chat
+// recording left only those checkpoints, so a conversation they cover and no chat file does is read
+// from them. <project> is a slug from ~/.gemini/projects.json now, the sha256 of the project folder
+// before. The writer (writer.ts) continues a session as a new Gemini CLI session in the installed format.
+
+const sha256 = (s: string) => createHash("sha256").update(s).digest("hex")
+const isHash = (s: string) => /^[0-9a-f]{64}$/.test(s)
+const oneLine = (s: string) => s.replace(/\s+/g, " ").trim()
+const titleFrom = (s: string | undefined) => (s && oneLine(s) ? oneLine(s).slice(0, 120) : undefined)
+
+function readText(p: string): string | undefined {
+  try {
+    return readFileSync(p, "utf8")
+  } catch {
+    return undefined
+  }
+}
+
+/** Project folder by tmp folder name: registry slugs, .project_root files, and sha256 names of every known folder. */
+function projectFolders(home: string): Map<string, string> {
+  const gemini = join(home, ".gemini")
+  const map = new Map<string, string>()
+  const reg = readJson<{ projects?: Record<string, unknown> }>(join(gemini, "projects.json"))?.projects
+  for (const [path, slug] of Object.entries(reg ?? {})) if (typeof slug === "string") map.set(slug, path)
+  for (const base of ["tmp", "history"]) {
+    for (const d of ls(join(gemini, base))) {
+      const root = readText(join(gemini, base, d, ".project_root"))?.trim()
+      if (root && !map.has(d)) map.set(d, root)
+    }
+  }
+  for (const root of [...map.values()]) map.set(sha256(root), root)
+  // Folders the person trusted, and the folders above them, may name a legacy sha256 folder too. A sha256
+  // match is exact, so extra candidates cannot give a wrong folder.
+  const trusted = readJson<Record<string, unknown>>(join(gemini, "trustedFolders.json"))
+  for (const path of trusted && typeof trusted === "object" && !Array.isArray(trusted) ? Object.keys(trusted) : []) {
+    for (let d = path; d.startsWith("/") && d !== "/"; d = dirname(d)) if (!map.has(sha256(d))) map.set(sha256(d), d)
+  }
+  return map
+}
+
+/** Absolute paths mentioned in tool arguments, to recover a legacy sha256-named project's folder. */
+function absPaths(v: unknown, out: Set<string>, depth = 0): Set<string> {
+  if (out.size > 200 || depth > 10) return out
+  if (typeof v === "string") {
+    if (v.startsWith("/") && !v.includes("\n")) out.add(v)
+  } else if (Array.isArray(v)) for (const x of v) absPaths(x, out, depth + 1)
+  else if (v && typeof v === "object") for (const x of Object.values(v)) absPaths(x, out, depth + 1)
+  return out
+}
+
+/** The folder whose sha256 is `hash`, found among the ancestors of `paths`. */
+function rootFromPaths(hash: string, paths: Iterable<string>): string | undefined {
+  for (const p of paths) {
+    for (let d = p; d && d !== "/" && d !== "."; d = dirname(d)) if (sha256(d) === hash) return d
+  }
+  return undefined
+}
+
+function projectCwd(folders: Map<string, string>, folder: string, projectHash: string | undefined, args: () => unknown): string | undefined {
+  return folders.get(folder) ?? (projectHash ? folders.get(projectHash) : undefined) ?? (isHash(folder) ? rootFromPaths(folder, absPaths(args(), new Set())) : undefined)
+}
+
+/** A user message's text, without the note brain puts first in a session it continued. */
+const userText = (m: { content?: unknown }) =>
+  toParts(m.content as Part[])
+    .filter((p, i) => !(i === 0 && typeof p.text === "string" && CONTINUED_NOTE.test(p.text)))
+    .map((p) => (typeof p.text === "string" && !p.thought ? p.text : ""))
+    .join("")
+/** A user message's text, unless Gemini CLI leaves the message out of the conversation. */
+const askText = (m: { content?: unknown }) => (ignoredUserContent(m.content as Part[]) ? "" : userText(m))
+
+interface Summary {
+  sessionId: string
+  kind?: string
+  projectHash?: string
+  startTime?: string
+  lastUpdated?: string
+  title?: string
+  /** Tool arguments, kept only for legacy files whose project folder must be recovered. */
+  args?: unknown
+}
+
+/**
+ * Enough of a session for the list. A legacy .json is one document, so it is parsed whole; a .jsonl is
+ * scanned for its metadata line, its {$set} records and its first user message only.
+ */
+function summarize(path: string): Summary | undefined {
+  if (path.endsWith(".json")) {
+    const conv = loadConversation(path)?.conv
+    if (!conv || !conv.messages.some((m) => m.type === "user")) return undefined
+    const first = conv.messages.find((m) => m.type === "user" && askText(m).trim())
+    return {
+      sessionId: conv.sessionId,
+      kind: conv.kind,
+      projectHash: conv.projectHash,
+      startTime: conv.startTime,
+      lastUpdated: conv.lastUpdated,
+      title: titleFrom(conv.summary) ?? titleFrom(first && userText(first)),
+      args: conv.messages.map((m) => m.toolCalls?.map((t) => t.args)),
+    }
+  }
+  const text = readText(path)
+  if (!text) return undefined
+  let meta: Record<string, any> = {}
+  let first: string | undefined
+  let line0 = true
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue
+    const isFirst = line0
+    line0 = false
+    if (!isFirst && !line.startsWith('{"$set"') && (first !== undefined || !line.includes('"type":"user"'))) continue
+    try {
+      const r = JSON.parse(line)
+      if (isFirst && typeof r.sessionId === "string") meta = { ...meta, ...r }
+      else if (r.$set && typeof r.$set === "object") {
+        meta = { ...meta, ...r.$set }
+        if (first === undefined && Array.isArray(r.$set.messages)) first = r.$set.messages.map((m: any) => (m?.type === "user" ? askText(m) : "")).find((t: string) => t.trim())
+      } else if (r.type === "user" && askText(r).trim()) first = askText(r)
+    } catch {
+      // a half-written line; the full read will count it
+    }
+  }
+  if (typeof meta.sessionId !== "string" || first === undefined) return undefined
+  return { sessionId: meta.sessionId, kind: meta.kind, projectHash: meta.projectHash, startTime: meta.startTime, lastUpdated: meta.lastUpdated, title: titleFrom(meta.summary) ?? titleFrom(first) }
+}
+
+// ---- checkpoints ------------------------------------------------------------------------------------
+
+interface Checkpoint {
+  path: string
+  at?: string
+  history: Array<{ role?: string; parts?: Part[] }>
+  /** The UI's history items; their ids are the epoch milliseconds they were shown. */
+  ui: Array<{ id?: unknown }>
+  args: unknown
+}
+
+/** "2025-07-28T15-52-02_821Z-file.ts-replace.json" was written at 2025-07-28T15:52:02.821Z. */
+function checkpointTime(name: string): string | undefined {
+  const m = name.match(/^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})_(\d{3})Z/)
+  return m ? `${m[1]}T${m[2]}:${m[3]}:${m[4]}.${m[5]}Z` : undefined
+}
+
+function readCheckpoint(path: string): Checkpoint | undefined {
+  const j = readJson<Record<string, any>>(path)
+  if (!j || !Array.isArray(j.clientHistory)) return undefined
+  return { path, at: checkpointTime(basename(path)), history: j.clientHistory, ui: Array.isArray(j.history) ? j.history : [], args: [j.toolCall?.args, j.filePath, j.clientHistory] }
+}
+
+/**
+ * Checkpoints grouped by conversation: each one holds the whole API history up to its edit, so a later
+ * checkpoint of the same conversation starts with an earlier one's history.
+ */
+function checkpointGroups(dir: string): Checkpoint[][] {
+  const groups: Checkpoint[][] = []
+  const key = (c: unknown) => JSON.stringify(c)
+  for (const name of ls(dir).filter((n) => n.endsWith(".json")).sort()) {
+    const cp = readCheckpoint(join(dir, name))
+    if (!cp || !cp.history.length) continue
+    const g = groups.find((g) => {
+      const last = g[g.length - 1]!
+      return last.history.length <= cp.history.length && last.history.every((c, i) => key(c) === key(cp.history[i]))
+    })
+    if (g) g.push(cp)
+    else groups.push([cp])
+  }
+  return groups
+}
+
+/** Before chat recording, Gemini CLI opened every conversation with its own environment context and an acknowledgement. */
+const isSetupContext = (c: { role?: string; parts?: Part[] } | undefined) =>
+  c?.role === "user" && (c.parts ?? []).some((p) => typeof p.text === "string" && p.text.startsWith("This is the Gemini CLI. We are setting up the context"))
+
+function checkpointRefs(dir: string, folder: string, spans: Array<[number, number]>, folders: Map<string, string>): SessionRef[] {
+  const refs: SessionRef[] = []
+  for (const g of checkpointGroups(join(dir, "checkpoints"))) {
+    const first = Date.parse(g[0]!.at ?? "")
+    const last = Date.parse(g[g.length - 1]!.at ?? "")
+    // Newer versions record the same conversation in chats/ too; read it from there.
+    if (Number.isFinite(first) && spans.some(([s, e]) => first <= e && last >= s)) continue
+    const latest = g[g.length - 1]!
+    const title = titleFrom(firstAsk(latest.history))
+    const stamp = basename(g[0]!.path).match(/^[^Z]*Z/)?.[0] ?? basename(g[0]!.path, ".json")
+    const cwd = projectCwd(folders, folder, undefined, () => g.map((c) => c.args))
+    refs.push({
+      tool: TOOL,
+      sourceId: `checkpoint-${stamp}-${folder.slice(0, 8)}`,
+      path: latest.path,
+      ...(title ? { title } : {}),
+      ...(cwd ? { cwd } : {}),
+      ...(latest.at ? { updatedAt: latest.at } : {}),
+      extra: { folder, checkpoints: g.map((c) => c.path) },
+    })
+  }
+  return refs
+}
+
+/** The first thing the person asked in a checkpoint's history, after Gemini CLI's own setup exchange. */
+const firstAsk = (history: Checkpoint["history"]) => {
+  const c = history.find((c, i) => c.role === "user" && !(i === 0 && isSetupContext(c)) && userText({ content: c.parts }).trim())
+  return c ? userText({ content: c.parts }) : undefined
+}
+
+function readCheckpointSession(ref: SessionRef, home: string): Session {
+  const files = (ref.extra?.checkpoints as string[] | undefined) ?? [ref.path]
+  const cps = files.map(readCheckpoint).filter((c): c is Checkpoint => Boolean(c))
+  const latest = cps[cps.length - 1]
+  if (!latest) throw new Error(`${ref.path} is not a Gemini CLI checkpoint`)
+  const shown = latest.ui.map((u) => (typeof u.id === "number" ? u.id : NaN)).filter(Number.isFinite)
+  const startedAt = shown.length ? iso(Math.min(...shown)) : cps[0]!.at
+  const folder = (ref.extra?.folder as string | undefined) ?? basename(dirname(dirname(latest.path)))
+  const cwd = ref.cwd ?? projectCwd(projectFolders(home), folder, undefined, () => cps.map((c) => c.args))
+  const title = ref.title ?? titleFrom(firstAsk(latest.history))
+  const h = header(TOOL, ref.sourceId, {
+    sourcePath: latest.path,
+    ...(title ? { title } : {}),
+    project: { ...(cwd ? { cwd } : {}), ...gitInfo(cwd) },
+    ...(startedAt ? { startedAt } : {}),
+    ...(latest.at ? { updatedAt: latest.at } : {}),
+  })
+  const lost = lossCounter()
+  const ctx = newCtx(h, lost)
+  let history = latest.history
+  if (isSetupContext(history[0])) {
+    lost.add("Gemini CLI setup context")
+    history = history.slice(history[1]?.role === "model" ? 2 : 1)
+  }
+  let turns: Turn[] = []
+  for (const c of history) {
+    if (c.role !== "user" && c.role !== "model") lost.add(`unknown record types: ${String(c.role)}`)
+    else turns.push(...partsToTurns(c.parts, c.role, undefined, ctx))
+  }
+  // The newest checkpoint is taken just before its own edit runs, so that call, the last turn, has no
+  // result yet; an open call before it was cancelled or interrupted.
+  const final = turns[turns.length - 1]
+  turns = closeOpenCalls(turns, ctx.pair.open(), ctx, (c) => (c === final ? "the checkpoint was saved before this call ran" : "the call was cancelled or interrupted"))
+  lost.add("timestamps and model names (checkpoints keep neither)")
+  lost.flush(h)
+  return { header: h, turns }
+}
+
+// ---- chat sessions ----------------------------------------------------------------------------------
+
+function toSession(conv: Conversation, path: string, cwd: string | undefined, extraLost: Array<[string, number]>, parent?: { id: string; sourceId: string }): Session {
+  const first = conv.messages.find((m) => m.type === "user" && askText(m).trim())
+  const title = titleFrom(conv.summary) ?? titleFrom(first && askText(first))
+  const startedAt = iso(conv.startTime)
+  const updatedAt = iso(conv.lastUpdated) ?? mtime(path)
+  const h = header(TOOL, parent?.sourceId ?? conv.sessionId, {
+    sourcePath: path,
+    ...(title ? { title } : {}),
+    project: { ...(cwd ? { cwd } : {}), ...gitInfo(cwd) },
+    ...(startedAt ? { startedAt } : {}),
+    ...(updatedAt ? { updatedAt } : {}),
+    ...(parent ? { parent: { id: parent.id, kind: "subagent" as const } } : {}),
+  })
+  const lost = lossCounter()
+  for (const [what, n] of extraLost) lost.add(what, n)
+  const ctx = newCtx(h, lost)
+  const turns = closeOpenCalls(messagesToTurns(conv.messages, ctx), ctx.pair.open(), ctx, () => "the call never got a response")
+  lost.flush(h)
+  return { header: h, turns }
+}
+
+function load(path: string): { conv: Conversation; lost: Array<[string, number]> } {
+  const l = loadConversation(path)
+  if (!l) throw new Error(`${path} is not a Gemini CLI session file`)
+  const lost: Array<[string, number]> = [...l.unknown].map(([k, n]) => [`unknown record types: ${k}`, n])
+  if (l.bad) lost.push(["unreadable lines", l.bad])
+  return { conv: l.conv, lost }
+}
+
+/**
+ * A session's subagents, each placed where it started among the parent's turns. Current versions keep
+ * them in chats/<parent session id>/<id>.jsonl; 0.33 wrote them beside the parent as session-*.json with
+ * the parent's session id and kind "subagent".
+ */
+function withChildren(s: Session, path: string, cwd: string | undefined): Session {
+  const chats = dirname(path)
+  const id = s.header.sourceId
+  const files = [
+    ...ls(join(chats, id)).filter((n) => /\.jsonl?$/.test(n)).map((n) => join(chats, id, n)),
+    ...ls(chats).filter((n) => /^session-.*\.json$/.test(n) && join(chats, n) !== path).map((n) => join(chats, n)),
+  ].sort()
+  const children: Session[] = []
+  for (const file of files) {
+    const nested = dirname(file) !== chats
+    try {
+      const { conv, lost } = load(file)
+      if (!nested && (conv.sessionId !== id || conv.kind !== "subagent")) continue
+      const sourceId = nested ? conv.sessionId : `${id}/${basename(file).replace(/\.json$/, "")}`
+      children.push(toSession(conv, file, cwd, lost, { id: s.header.id, sourceId }))
+    } catch {
+      // A file beside the session that cannot be read may be any session of the project, not this one's.
+      if (nested) s.header.lost.push(`unreadable subagent session (${basename(file)})`)
+    }
+  }
+  if (!children.length) return s
+  const turns = [...s.turns]
+  for (const c of children) {
+    const at = Date.parse(c.header.startedAt ?? "")
+    const end = Date.parse(c.header.updatedAt ?? "")
+    let i = Number.isFinite(at) ? turns.findIndex((x) => x.at !== undefined && Date.parse(x.at) > at) : -1
+    // A tool call's time is when it finished, so the call that ran the subagent is timed after the
+    // subagent's last message: among the tool turns found by time, the first call that ended after the
+    // subagent did is its call, and the subagent goes after that call's result and edits.
+    let callId: string | undefined
+    for (let j = i; j >= 0 && j < turns.length && Number.isFinite(end) && /^(tool_call|tool_result|file_edit|subagent)$/.test(turns[j]!.kind); j++) {
+      const x = turns[j]!
+      if (x.kind === "tool_call" && x.at && Date.parse(x.at) >= end) {
+        callId = x.id
+        i = j + 1
+        while (i < turns.length && (turns[i]!.kind === "tool_result" || turns[i]!.kind === "file_edit") && (turns[i] as { callId?: string }).callId === callId) i++
+        break
+      }
+    }
+    // Never between a call and its result.
+    while (i >= 0 && i < turns.length && turns[i]!.kind === "tool_result") i++
+    const t: Turn = { kind: "subagent", ...(c.header.startedAt ? { at: c.header.startedAt } : {}), sessionId: c.header.id, ...(callId ? { callId } : {}), ...(c.header.title ? { description: c.header.title } : {}) }
+    if (i < 0 || i >= turns.length) turns.push(t)
+    else turns.splice(i, 0, t)
+  }
+  return { ...s, turns, children }
+}
+
+/** Which file stands for a session id: a main session over a subagent, the live .jsonl over its legacy .json, then the newest. */
+function rank(r: SessionRef): string {
+  return `${r.extra?.subagent ? 0 : 1}${r.path.endsWith(".jsonl") ? 1 : 0}${r.updatedAt ?? ""}`
+}
+
+export const reader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home) {
+    const tmp = join(home, ".gemini", "tmp")
+    if (!isDir(tmp)) return []
+    const folders = projectFolders(home)
+    const refs: SessionRef[] = []
+    for (const folder of ls(tmp)) {
+      const dir = join(tmp, folder)
+      if (!isDir(dir)) continue
+      const chats = join(dir, "chats")
+      const byId = new Map<string, SessionRef>()
+      const spans: Array<[number, number]> = []
+      for (const name of ls(chats)) {
+        if (!/^session-.*\.jsonl?$/.test(name)) continue
+        const path = join(chats, name)
+        const s = summarize(path)
+        if (!s) continue
+        const updatedAt = iso(s.lastUpdated) ?? mtime(path)
+        spans.push([Date.parse(iso(s.startTime) ?? updatedAt ?? ""), Date.parse(updatedAt ?? "")])
+        const cwd = projectCwd(folders, folder, s.projectHash, () => s.args)
+        const ref: SessionRef = {
+          tool: TOOL,
+          sourceId: s.sessionId,
+          path,
+          ...(s.title ? { title: s.title } : {}),
+          ...(cwd ? { cwd } : {}),
+          ...(updatedAt ? { updatedAt } : {}),
+          extra: { folder, ...(s.kind === "subagent" ? { subagent: true } : {}) },
+        }
+        // One id can have several files: 0.33's subagents share their parent's id, and resuming a legacy
+        // .json writes a .jsonl copy beside it. The main, live file stands for the session.
+        const prev = byId.get(s.sessionId)
+        if (!prev || rank(ref) > rank(prev)) byId.set(s.sessionId, ref)
+      }
+      refs.push(...byId.values(), ...checkpointRefs(dir, folder, spans, folders))
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref, home) {
+    if (ref.extra?.checkpoints) return readCheckpointSession(ref, home)
+    const { conv, lost } = load(ref.path)
+    const folder = (ref.extra?.folder as string | undefined) ?? basename(dirname(dirname(ref.path)))
+    const cwd = ref.cwd ?? projectCwd(projectFolders(home), folder, conv.projectHash, () => conv.messages.map((m) => m.toolCalls?.map((t) => t.args)))
+    return withChildren(toSession(conv, ref.path, cwd, lost), ref.path, cwd)
+  },
+}
+
+export const readers: Reader[] = [reader]
+export const writers: Writer[] = [geminiNativeWriter]