@100xprompt/brain 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,354 @@
+import { createHash, randomUUID } from "node:crypto"
+import { mkdirSync, readFileSync, renameSync, rmdirSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { basename, dirname, join, resolve } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir, ls, readJson, versionOf } from "../../fsutil.ts"
+import type { Session } from "../../session/types.ts"
+import { countTurns, header, lossCounter, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { ALIASES, type Call, clock, drops, imageData, mapCall, realCwd, regroup, resultOutput, shellQuote, titleOf, type ToolSpec } from "./exchanges.ts"
+import { closeOpenCalls, continuedNote, LABEL, loadConversation, type MessageRecord, messagesToTurns, newCtx, type Part, SNAPSHOT_ACK, snapshotOf, TOOL } from "./records.ts"
+
+// Continues a portable session in Gemini CLI as a new session of its own: a chat file in the project's
+// folder, ~/.gemini/tmp/<project>/chats/, in the format the installed version loads. Before 0.39.0 that is
+// one ConversationRecord JSON document (session-<time>-<id8>.json); from 0.39.0 it is the append-only JSONL
+// log (session-<time>-<id8>.jsonl: a metadata line, one line per message, {$set} for the summary). Checked
+// against 0.33.1 (installed here) and 0.67.0: chatRecordingService and sessionUtils (core) and the CLI's
+// sessionUtils, which list a chat file, and convertSessionToClientHistory, which replays it to the model.
+//
+// <project> is the short name Gemini CLI's ProjectRegistry gives the folder (~/.gemini/projects.json and
+// .project_root markers in tmp/ and history/); the writer finds or claims it the same way. A project still
+// in its pre-registry folder (tmp/<sha256 of the folder>) is written there: Gemini CLI copies that folder to
+// the new name on its next start, and a new name holding chats already would stop that copy.
+//
+// Messages are written in the shape Gemini CLI has always recorded and still replays: user messages with
+// Part[] content; one gemini message per model response, with its text, its readable thoughts (thoughts[],
+// which the UI shows and 0.67 sends back as thought parts) and its tool calls, each holding its own
+// functionResponse result. Tool names map to Gemini CLI's own where a call's arguments allow it. The note
+// on where the session came from is the first part of the first user message; displayContent leaves it
+// out, so the model reads it and the screen shows the person's words. A compacted session starts from its
+// last summary, written as Gemini CLI's compression writes one (a <state_snapshot> user message and its
+// acknowledgement). `summary` names the session in the list (and stops Gemini CLI asking a model for one).
+
+/** Versions this writer was checked against; others get the brief. */
+export const TESTED_VERSIONS = ["0.33.1", "0.67.0"]
+
+/** Gemini CLI wrote whole-file JSON sessions before 0.39.0 and append-only JSONL from it on. */
+export function formatFor(version: string): "json" | "jsonl" {
+  const [a = 0, b = 0] = version.split(".").map(Number)
+  return a > 0 || b >= 39 ? "jsonl" : "json"
+}
+
+/** The installed Gemini CLI version ("0.33.1"), or undefined when it is not installed. */
+export const geminiVersion = (bin = "gemini") => versionOf(bin)?.match(/(\d+\.\d+\.\d+)/)?.[1]
+
+const sha256 = (s: string) => createHash("sha256").update(s).digest("hex")
+
+/** Gemini CLI's own tool for a portable call, by what the call does. */
+function geminiTool(call: Call): ToolSpec | undefined {
+  const input = (call.input ?? {}) as Record<string, unknown>
+  switch (call.toolKind) {
+    case "read":
+      return { name: "read_file", args: { file_path: ALIASES.file } }
+    case "edit":
+      return { name: "replace", args: { file_path: ALIASES.file, old_string: ALIASES.oldText, new_string: ALIASES.newText } }
+    case "write":
+      return { name: "write_file", args: { file_path: ALIASES.file, content: ALIASES.content } }
+    case "shell":
+      return { name: "run_shell_command", args: { command: ALIASES.command } }
+    case "search":
+      return { name: /glob/i.test(call.name) ? "glob" : "grep_search", args: { pattern: ALIASES.pattern, dir_path: ALIASES.dir } }
+    case "list":
+      return { name: "list_directory", args: { dir_path: ALIASES.dir } }
+    case "web":
+      return ALIASES.url.some((k) => input[k] !== undefined)
+        ? { name: "web_fetch", args: { prompt: ["prompt", ...ALIASES.url] } }
+        : { name: "google_web_search", args: { query: ALIASES.query } }
+    case "todo":
+      return { name: "write_todos", args: { todos: ["todos"] } }
+    default:
+      return undefined
+  }
+}
+
+export interface ConversationPlan {
+  /** The ConversationRecord, as the whole-file format stores it. */
+  record: { sessionId: string; projectHash: string; startTime: string; lastUpdated: string; messages: MessageRecord[]; kind: "main"; summary: string }
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+}
+
+/** The new session `sessionId` continuing `session`. Pure apart from reading attached images. */
+export function planConversation(session: Session, opts: { sessionId: string; projectHash: string; now: Date; version: string }): ConversationPlan {
+  const { drop, list } = drops()
+  const exchanges = regroup(session, { fromLastCompaction: true, keepReasoning: true, drop })
+  const label = toolLabel(session.header.tool)
+  const stamp = clock(session, opts.now)
+  const expect = { users: 0, assistants: 0, calls: 0 }
+  const jsonl = formatFor(opts.version) === "jsonl"
+  let lastModel = session.header.models[session.header.models.length - 1] ?? "unknown"
+  // Call ids as Gemini CLI makes them when the API gives none: `<name>_<ms>_<n>`, prefixed `<name>__` from 0.4x on.
+  let n = 0
+  const callId = (name: string, at: string) => {
+    const base = `${name}_${Date.parse(at)}_${n++}`
+    return jsonl ? `${name}__${base}` : base
+  }
+  const note: Part = { text: continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10)) }
+  let noted = false
+  const messages: MessageRecord[] = []
+  const user = (at: string | undefined, parts: Part[]) => {
+    const m: MessageRecord & { displayContent?: Part[] } = { id: randomUUID(), timestamp: stamp(at), type: "user", content: noted ? parts : [note, ...parts] }
+    if (!noted && parts.length) m.displayContent = parts
+    noted = true
+    messages.push(m)
+  }
+  const gemini = (at: string | undefined, fields: Partial<MessageRecord>) => {
+    const m: MessageRecord = { id: randomUUID(), timestamp: stamp(at), type: "gemini", content: "", thoughts: [], tokens: null, model: lastModel, ...fields }
+    messages.push(m)
+    return m
+  }
+
+  // A session that opens with the model gets the note on its own first.
+  if (exchanges[0] && exchanges[0].kind === "model") user(exchanges[0].at, [])
+  exchanges.forEach((x, i) => {
+    if (x.kind === "user") {
+      let text = x.text
+      const images: Part[] = []
+      for (const a of x.attachments) {
+        if (a.kind === "file") {
+          if (a.path) text += `\n\n[Attached file: ${a.path}]`
+          continue
+        }
+        const img = imageData(a)
+        if (img) images.push({ inlineData: img })
+        else if (a.path) drop("images that could not be attached")
+      }
+      const parts: Part[] = [...(text.trim() ? [{ text }] : []), ...images]
+      if (!parts.length) return
+      user(x.at, parts)
+      if (text.trim()) expect.users++
+    } else if (x.kind === "compaction") {
+      user(x.at, [{ text: snapshotOf(label, x.summary) }])
+      // Two model messages side by side would reach the model as two model turns; the response itself follows.
+      if (exchanges[i + 1]?.kind !== "model") gemini(x.at, { content: SNAPSHOT_ACK })
+    } else {
+      if (x.model) lastModel = x.model
+      const m = gemini(x.at, { content: x.text, model: lastModel })
+      if (x.text.trim()) expect.assistants++
+      // Thought summaries are {subject, description}; brain's reasoning text is the description.
+      m.thoughts = x.thoughts.map((t) => ({ subject: "", description: t.text, timestamp: stamp(t.at) }))
+      if (x.usage) {
+        // Gemini's input count includes the cached part.
+        const input = (x.usage.input ?? 0) + (x.usage.cacheRead ?? 0)
+        const output = x.usage.output ?? 0
+        m.tokens = { input, output, cached: x.usage.cacheRead ?? 0, thoughts: 0, tool: 0, total: input + output } as MessageRecord["tokens"]
+      }
+      if (x.calls.length) {
+        m.toolCalls = x.calls.map((a) => {
+          const { name, args } = mapCall(a.call, geminiTool(a.call))
+          const at = stamp(a.result?.at ?? a.call.at)
+          const id = callId(name, at)
+          if (!a.result) drop("tool calls without a result (closed as errors)")
+          if (a.edits.length) drop("file edit diffs (Gemini CLI keeps one only with the whole file before and after)", a.edits.length)
+          const ok = a.result?.ok ?? false
+          const output = resultOutput(a.result)
+          expect.calls++
+          return {
+            id,
+            name,
+            args,
+            result: [{ functionResponse: { id, name, response: ok ? { output } : { error: output } } }],
+            status: ok ? "success" : "error",
+            timestamp: at,
+            resultDisplay: output,
+            displayName: name,
+            description: "",
+            renderOutputAsMarkdown: false,
+          }
+        })
+      }
+    }
+  })
+  if (!messages.length) throw new Error("nothing Gemini CLI can resume: the session has no messages")
+  return {
+    record: {
+      sessionId: opts.sessionId,
+      projectHash: opts.projectHash,
+      startTime: messages[0]!.timestamp!,
+      lastUpdated: opts.now.toISOString(),
+      messages,
+      kind: "main",
+      summary: `${titleOf(session)} (from ${label})`,
+    },
+    lost: list(),
+    expect,
+  }
+}
+
+/** The file's text in the format the version loads. */
+export function serialize(plan: ConversationPlan, format: "json" | "jsonl"): string {
+  if (format === "json") return JSON.stringify(plan.record, null, 2)
+  const { messages, summary, ...meta } = plan.record
+  return `${[meta, ...messages, { $set: { summary } }].map((r) => JSON.stringify(r)).join("\n")}\n`
+}
+
+// ---- the project's folder ---------------------------------------------------------------------------
+
+const readText = (p: string) => {
+  try {
+    return readFileSync(p, "utf8")
+  } catch {
+    return undefined
+  }
+}
+
+const slugify = (text: string) =>
+  text
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "") || "project"
+
+export interface ProjectFolder {
+  /** tmp/<name>: where the chats folder goes. */
+  dir: string
+  /** .project_root markers to create, by path. */
+  markers: string[]
+  /** The registry entry to add, when the folder has none. */
+  register?: { path: string; slug: string }
+}
+
+/**
+ * The project's folder under ~/.gemini/tmp, as Gemini CLI's ProjectRegistry.getShortId finds or claims it:
+ * the registry's name when its markers agree, else a folder whose .project_root names the project, else a
+ * new name from the folder's base name (name, name-1, ...) that no registry entry or marker owns.
+ */
+export function projectFolder(home: string, cwd: string): ProjectFolder {
+  const gemini = join(home, ".gemini")
+  const project = resolve(cwd)
+  const tmp = join(gemini, "tmp")
+  const bases = [tmp, join(gemini, "history")]
+  const owner = (base: string, slug: string) => readText(join(base, slug, ".project_root"))?.trim()
+  const legacy = join(tmp, sha256(project))
+  const registry = readJson<{ projects?: Record<string, string> }>(join(gemini, "projects.json"))?.projects ?? {}
+  let slug: string | undefined = registry[project]
+  if (slug && bases.some((b) => owner(b, slug!) !== undefined && resolve(owner(b, slug!)!) !== project)) slug = undefined
+  for (const base of bases) for (const d of slug ? [] : ls(base)) if (!slug && owner(base, d) !== undefined && resolve(owner(base, d)!) === project) slug = d
+  if (!slug) {
+    const taken = new Set(Object.values(registry))
+    const root = slugify(basename(project) || "project")
+    for (let i = 0; !slug; i++) {
+      const c = i === 0 ? root : `${root}-${i}`
+      if (!taken.has(c) && bases.every((b) => owner(b, c) === undefined || resolve(owner(b, c)!) === project)) slug = c
+    }
+  }
+  // Gemini CLI copies a pre-registry folder to the new name only while that name holds nothing but its marker.
+  const fresh = ls(join(tmp, slug)).every((f) => f === ".project_root")
+  if (isDir(legacy) && fresh) return { dir: legacy, markers: [] }
+  return {
+    dir: join(tmp, slug),
+    markers: bases.map((b) => join(b, slug!, ".project_root")).filter((p) => !exists(p)),
+    ...(registry[project] === slug ? {} : { register: { path: project, slug } }),
+  }
+}
+
+/** Adds the registry entry under Gemini CLI's own lock (proper-lockfile's `<file>.lock` folder), atomically. */
+function register(home: string, entry: { path: string; slug: string }) {
+  const file = join(home, ".gemini", "projects.json")
+  const lock = `${file}.lock`
+  mkdirSync(join(home, ".gemini"), { recursive: true })
+  for (let tries = 0; ; tries++) {
+    try {
+      mkdirSync(lock)
+      break
+    } catch {
+      // A lock Gemini CLI left behind goes stale after 10 s, as proper-lockfile treats it.
+      let age = 0
+      try {
+        age = Date.now() - statSync(lock).mtimeMs
+      } catch {}
+      if (age > 10_000) rmdirSync(lock)
+      else if (tries > 50) throw new Error(`Gemini CLI is updating ${file}; try again`)
+      else Bun.sleepSync(100)
+    }
+  }
+  try {
+    const data = readJson<{ projects?: Record<string, string> }>(file) ?? {}
+    const next = { ...data, projects: { ...(data.projects ?? {}), [entry.path]: entry.slug } }
+    const tmp = `${file}.${randomUUID()}.tmp`
+    writeFileSync(tmp, JSON.stringify(next, null, 2))
+    renameSync(tmp, file)
+  } finally {
+    rmdirSync(lock)
+  }
+}
+
+// ---- the writer -------------------------------------------------------------------------------------
+
+/** The Gemini CLI writer; `version` and `bin` are for tests, which must not depend on the installed binary. */
+export function geminiWriter(opts: { bin?: string; version?: string } = {}): Writer {
+  const installed = () => opts.version ?? geminiVersion(opts.bin)
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed()
+      if (!v) return { ok: false, why: "Gemini CLI is not installed (`gemini --version` did not run)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Gemini CLI ${v} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; Gemini CLI lists and resumes sessions per project folder` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const version = installed() ?? TESTED_VERSIONS[TESTED_VERSIONS.length - 1]!
+      const format = formatFor(version)
+      const cwd = realCwd(w.cwd)
+      const now = new Date()
+      const folder = projectFolder(w.home, cwd)
+      const chats = join(folder.dir, "chats")
+      let sessionId = randomUUID()
+      const name = () => `session-${now.toISOString().slice(0, 16).replace(/:/g, "-")}-${sessionId.slice(0, 8)}.${format}`
+      while (exists(join(chats, name()))) sessionId = randomUUID()
+      const path = join(chats, name())
+      const plan = planConversation(session, { sessionId, projectHash: sha256(cwd), now, version })
+      const written = [path, ...folder.markers, ...(folder.register ? [join(w.home, ".gemini", "projects.json")] : [])]
+      if (!w.dryRun) {
+        for (const m of folder.markers) {
+          mkdirSync(dirname(m), { recursive: true })
+          // "wx", as Gemini CLI claims a name: a marker that appeared meanwhile is left as it is.
+          writeFileSync(m, resolve(cwd), { flag: "wx" })
+        }
+        if (folder.register) register(w.home, folder.register)
+        mkdirSync(chats, { recursive: true })
+        // "wx": a new file only; an existing session is never touched.
+        writeFileSync(path, serialize(plan, format), { flag: "wx" })
+        const back = loadConversation(path)
+        const h = header(TOOL, sessionId)
+        const ctx = newCtx(h, lossCounter())
+        const turns = back ? closeOpenCalls(messagesToTurns(back.conv.messages, ctx), ctx.pair.open(), ctx, () => "") : []
+        const got = countTurns({ header: h, turns })
+        const pairs = unpaired({ header: h, turns })
+        if (!back || got.user !== plan.expect.users || got.assistant !== plan.expect.assistants || got.tool_call !== plan.expect.calls || ctx.pair.open().length || pairs.calls.length || pairs.results.length) {
+          rmSync(path, { force: true })
+          throw new Error(
+            `the new Gemini CLI session did not read back as written (users ${got.user}/${plan.expect.users}, replies ${got.assistant}/${plan.expect.assistants}, tool calls ${got.tool_call}/${plan.expect.calls}); nothing was kept`,
+          )
+        }
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId,
+        written,
+        open: `cd ${shellQuote(cwd)} && gemini --resume ${sessionId}`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const geminiNativeWriter = geminiWriter()

package/src/adapters/goose/index.ts

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { gooseReader } from "./reader.ts"
+import { gooseImportWriter } from "./writer.ts"
+
+// Goose (AAIF, formerly Block): reads sessions.db and pre-1.10 JSONL sessions, and continues any session
+// through Goose's own `session import`.
+export const readers: Reader[] = [gooseReader]
+export const writers: Writer[] = [gooseImportWriter]

package/src/adapters/goose/reader.ts

@@ -0,0 +1,138 @@
+import type { Database } from "bun:sqlite"
+import { basename, join } from "node:path"
+import { exists, gitInfo, ls, mtime, readJsonl } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import type { Session } from "../../session/types.ts"
+import { header, iso, noteModel } from "../../session/util.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { type GooseMessage, LABEL, TOOL, dbPath, sessionsDir, turnsOf } from "./records.ts"
+
+// Goose: sessions in ~/.local/share/goose/sessions/sessions.db (read from a copy, with its write-ahead log),
+// or legacy <id>.jsonl files there when Goose has never created the database. Only the session types
+// Goose's own `session list` shows are listed (user and scheduled), and only those with messages.
+
+/** SQLite's CURRENT_TIMESTAMP text ("2026-11-08 05:18:00") is UTC without a zone. */
+const sqlTime = (v: unknown) => (typeof v === "string" && /^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d/.test(v) ? iso(`${v.replace(" ", "T")}Z`) : iso(v))
+
+const modelOf = (json: unknown): string | undefined => {
+  if (typeof json !== "string") return undefined
+  try {
+    const m = JSON.parse(json) as { model_name?: unknown }
+    return typeof m.model_name === "string" ? m.model_name : undefined
+  } catch {
+    return undefined
+  }
+}
+
+export function listDb(d: Database, path: string): SessionRef[] {
+  const rows = d
+    .query(
+      `SELECT s.id, s.name, s.working_dir, s.updated_at, MAX(m.created_timestamp) AS last
+       FROM sessions s JOIN messages m ON m.session_id = s.id
+       WHERE s.session_type IN ('user', 'scheduled')
+       GROUP BY s.id`,
+    )
+    .all() as Array<Record<string, any>>
+  return rows.map((r) => {
+    const updatedAt = iso(Number(r.last)) ?? sqlTime(r.updated_at)
+    return {
+      tool: TOOL,
+      sourceId: String(r.id),
+      path,
+      ...(r.name ? { title: String(r.name) } : {}),
+      ...(r.working_dir ? { cwd: String(r.working_dir) } : {}),
+      ...(updatedAt ? { updatedAt } : {}),
+      extra: { source: "db" },
+    }
+  })
+}
+
+export function readDb(d: Database, path: string, id: string, home: string): Session {
+  const s = d.query("SELECT * FROM sessions WHERE id = ?").get(id) as Record<string, any> | null
+  if (!s) throw new Error(`no Goose session ${id} in ${path}`)
+  const rows = d
+    .query("SELECT role, content_json, created_timestamp, metadata_json FROM messages WHERE session_id = ? ORDER BY created_timestamp, id")
+    .all(id) as Array<Record<string, any>>
+  const messages: GooseMessage[] = []
+  let bad = 0
+  for (const r of rows) {
+    try {
+      messages.push({ role: String(r.role), created: Number(r.created_timestamp), content: JSON.parse(String(r.content_json)), ...(r.metadata_json ? { metadata: JSON.parse(String(r.metadata_json)) } : {}) })
+    } catch {
+      bad++
+    }
+  }
+  const cwd = s.working_dir ? String(s.working_dir) : undefined
+  const h = header(TOOL, id, {
+    sourcePath: path,
+    ...(s.name ? { title: String(s.name) } : {}),
+    project: cwd ? { cwd, ...gitInfo(cwd, home) } : {},
+    ...(sqlTime(s.created_at) ? { startedAt: sqlTime(s.created_at)! } : {}),
+  })
+  noteModel(h, modelOf(s.model_config_json))
+  if (s.parent_session_id) h.parent = { id: `${TOOL}:${s.parent_session_id}`, kind: "fork" }
+  return finish(h, messages, bad)
+}
+
+function finish(h: Session["header"], messages: GooseMessage[], bad: number): Session {
+  const { turns, continued } = turnsOf(messages, h)
+  if (bad) h.lost.push(`unreadable messages (${bad})`)
+  if (continued) h.parent = { id: continued, kind: "continued" }
+  const times = messages.map((m) => iso(m.created)).filter((t): t is string => !!t)
+  if (!h.startedAt && times[0]) h.startedAt = times[0]
+  if (times.length) h.updatedAt = times[times.length - 1]
+  return { header: h, turns }
+}
+
+/** A pre-1.10 session file: a metadata line, then one message per line. */
+function readLegacy(path: string, home: string): Session {
+  const { rows, bad } = readJsonl(path)
+  if (!rows.length) throw new Error(`${path} has no readable lines`)
+  const [meta, ...messages] = rows
+  const cwd = typeof meta!.working_dir === "string" && meta!.working_dir ? meta!.working_dir : undefined
+  const h = header(TOOL, basename(path, ".jsonl"), {
+    sourcePath: path,
+    ...(typeof meta!.description === "string" && meta!.description ? { title: meta!.description } : {}),
+    project: cwd ? { cwd, ...gitInfo(cwd, home) } : {},
+  })
+  return finish(h, messages as unknown as GooseMessage[], bad)
+}
+
+export const gooseReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+  async list(home) {
+    const db = dbPath(home)
+    if (exists(db)) {
+      try {
+        return withSnapshot(db, (d) => listDb(d, db)).sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+      } catch {
+        return []
+      }
+    }
+    const refs: SessionRef[] = []
+    for (const name of ls(sessionsDir(home))) {
+      if (!name.endsWith(".jsonl")) continue
+      const path = join(sessionsDir(home), name)
+      const { rows } = readJsonl(path)
+      const meta = rows[0]
+      if (!meta || rows.length < 2) continue
+      const updatedAt = mtime(path)
+      refs.push({
+        tool: TOOL,
+        sourceId: basename(name, ".jsonl"),
+        path,
+        ...(typeof meta.description === "string" && meta.description ? { title: meta.description } : {}),
+        ...(typeof meta.working_dir === "string" && meta.working_dir ? { cwd: meta.working_dir } : {}),
+        ...(updatedAt ? { updatedAt } : {}),
+        extra: { source: "jsonl" },
+      })
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+  async read(ref, home) {
+    if (!exists(ref.path)) throw new Error(`Goose session store not found: ${ref.path}`)
+    if (ref.path.endsWith(".jsonl")) return readLegacy(ref.path, home)
+    return withSnapshot(ref.path, (d) => readDb(d, ref.path, ref.sourceId, home))
+  },
+}