@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/antigravity/reader.ts

@@ -0,0 +1,424 @@
+import type { Database } from "bun:sqlite"
+import { statSync } from "node:fs"
+import { basename, dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { exists, gitInfo, ls, mtime } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import type { Session, SessionHeader, Turn } from "../../session/types.ts"
+import { clip, header, lossCounter } from "../../session/util.ts"
+import { CONTINUED_NOTE } from "../claude-code/records.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { allBytes, bytesOf, decode, numberOf, textOf, type Field } from "./proto.ts"
+import {
+  CONVERSATION_FILE,
+  LABEL,
+  LINK_KEY,
+  MAX_DB_BYTES,
+  MAX_STEPS,
+  PAYLOAD_FIELD,
+  STATUS,
+  STEP,
+  STORES,
+  TOOL,
+  antigravityToolKind,
+  conversationsDir,
+  decodeCall,
+  entriesOf,
+  hasThinking,
+  sqlTime,
+  summariesPath,
+  timestampOf,
+  workspaceOf,
+  type NativeCall,
+} from "./records.ts"
+
+// Reads Antigravity conversations (records.ts) from the CLI's store and the IDE's two. Each conversation
+// database is read from a copy with its write-ahead log, so a live one reads consistently; the summaries
+// database beside it gives the title, folder and time, reading only the columns it needs (the IDE's table has
+// more). The projection follows session-migrate's: user inputs are user turns, planner responses are replies
+// and tool calls, generic tool steps and the run_command, view_file, shell_exec and MCP steps are results.
+// Private thinking never becomes a turn: it is only counted. Every other step type is counted by number.
+
+interface Summary {
+  title?: string
+  cwd?: string
+  updatedAt?: string
+  parent?: string
+}
+
+/** A local folder from a file:// URI; undefined for anything else. */
+function pathOfUri(uri: unknown): string | undefined {
+  if (typeof uri !== "string" || !uri.startsWith("file://")) return undefined
+  try {
+    const u = new URL(uri)
+    return u.host ? undefined : fileURLToPath(u)
+  } catch {
+    return undefined
+  }
+}
+
+const WANTED = ["conversation_id", "title", "workspace_uris", "last_modified_time", "parent_conversation_id"]
+
+/** Summary rows by conversation id, from whichever of the wanted columns the table has. */
+function summaryRows(d: Database, id?: string): Map<string, Summary> {
+  const out = new Map<string, Summary>()
+  const cols = new Set((d.query("PRAGMA table_info(conversation_summaries)").all() as Array<{ name: string }>).map((c) => c.name))
+  if (!cols.has("conversation_id")) return out
+  const sql = `SELECT ${WANTED.filter((c) => cols.has(c))
+    .map((c) => `"${c}"`)
+    .join(", ")} FROM conversation_summaries${id ? " WHERE conversation_id = ?" : ""}`
+  const rows = (id ? d.query(sql).all(id) : d.query(sql).all()) as Array<Record<string, unknown>>
+  for (const r of rows) {
+    let cwd: string | undefined
+    try {
+      const uris = JSON.parse(String(r.workspace_uris ?? ""))
+      if (Array.isArray(uris)) cwd = pathOfUri(uris[0])
+    } catch {
+      // no folder
+    }
+    out.set(String(r.conversation_id), {
+      ...(typeof r.title === "string" && r.title.trim() ? { title: r.title } : {}),
+      ...(cwd ? { cwd } : {}),
+      ...(sqlTime(r.last_modified_time) ? { updatedAt: sqlTime(r.last_modified_time)! } : {}),
+      ...(typeof r.parent_conversation_id === "string" && r.parent_conversation_id ? { parent: r.parent_conversation_id } : {}),
+    })
+  }
+  return out
+}
+
+/** A store's summaries, read from a copy; none when the database is missing or unreadable. */
+function readSummaries(path: string, id?: string): Map<string, Summary> {
+  if (!exists(path)) return new Map()
+  try {
+    return withSnapshot(path, (d) => summaryRows(d, id))
+  } catch {
+    return new Map()
+  }
+}
+
+export const antigravityReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+  async list(home) {
+    const found = new Map<string, SessionRef>()
+    for (const store of STORES) {
+      const dir = conversationsDir(home, store)
+      // Only the SQLite conversations: the IDE's <uuid>.pb files are encrypted.
+      const files = ls(dir).filter((n) => CONVERSATION_FILE.test(n))
+      if (!files.length) continue
+      const sums = readSummaries(summariesPath(home, store))
+      for (const name of files) {
+        const id = name.slice(0, -3)
+        const path = join(dir, name)
+        const s = sums.get(id)
+        const updatedAt = s?.updatedAt ?? mtime(path)
+        const ref: SessionRef = {
+          tool: TOOL,
+          sourceId: id,
+          path,
+          ...(s?.title ? { title: s.title } : {}),
+          ...(s?.cwd ? { cwd: s.cwd } : {}),
+          ...(updatedAt ? { updatedAt } : {}),
+          extra: { store },
+        }
+        // The same conversation in two stores: the newer copy.
+        const prev = found.get(id)
+        if (!prev || (ref.updatedAt ?? "") > (prev.updatedAt ?? "")) found.set(id, ref)
+      }
+    }
+    return [...found.values()].sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+  async read(ref) {
+    if (!exists(ref.path)) throw new Error(`Antigravity conversation not found: ${ref.path}`)
+    if (statSync(ref.path).size > MAX_DB_BYTES) throw new Error(`Antigravity conversation is larger than ${MAX_DB_BYTES} bytes: ${ref.path}`)
+    const id = basename(ref.path).replace(/\.db$/i, "")
+    const s = readSummaries(join(dirname(dirname(ref.path)), "conversation_summaries.db"), id).get(id)
+    const title = s?.title ?? ref.title
+    const cwd = s?.cwd ?? ref.cwd
+    const updatedAt = s?.updatedAt ?? ref.updatedAt
+    return withSnapshot(ref.path, (d) =>
+      readConversation(d, id, { path: ref.path, ...(title ? { title } : {}), ...(cwd ? { cwd } : {}), ...(updatedAt ? { updatedAt } : {}), ...(s?.parent ? { parent: s.parent } : {}) }),
+    )
+  },
+}
+
+export interface Where {
+  path: string
+  title?: string
+  cwd?: string
+  updatedAt?: string
+  /** The conversation this one was spawned from, per the summaries table. */
+  parent?: string
+}
+
+const stamp = (at: string | undefined) => (at ? { at } : {})
+
+/** A nested message, or undefined when it is absent or not a message. */
+function tryMessage(fields: Field[] | undefined, no: number): Field[] | undefined {
+  const b = fields && bytesOf(fields, no)
+  if (!b) return undefined
+  try {
+    return decode(b)
+  } catch {
+    return undefined
+  }
+}
+
+function tryCall(b: Uint8Array | undefined): NativeCall | undefined {
+  if (!b) return undefined
+  try {
+    return decodeCall(b)
+  } catch {
+    return undefined
+  }
+}
+
+/** Step types read as tool results by `builtin`. */
+const BUILTIN: Record<number, true> = { [STEP.runCommand]: true, [STEP.viewFile]: true, [STEP.shellExec]: true }
+
+/** A text from a built-in tool step: what it was given and what it returned. */
+function builtin(type: number, body: Field[]): { name: string; input: Record<string, unknown>; output?: string } {
+  if (type === STEP.runCommand) {
+    const command = textOf(body, 23) || textOf(body, 25)
+    const out = tryMessage(body, 21) ?? tryMessage(body, 26)
+    const output = (out && textOf(out, 1)) || textOf(body, 4) || textOf(body, 5)
+    return { name: "run_command", input: command ? { command } : {}, ...(output !== undefined ? { output } : {}) }
+  }
+  if (type === STEP.viewFile) {
+    const path = textOf(body, 1)
+    const output = textOf(body, 4) || textOf(body, 9)
+    return { name: "view_file", input: path ? { AbsolutePath: path } : {}, ...(output !== undefined ? { output } : {}) }
+  }
+  const command = textOf(body, 1)
+  const output = textOf(body, 3) || textOf(body, 4)
+  return { name: "shell_exec", input: command ? { command } : {}, ...(output !== undefined ? { output } : {}) }
+}
+
+/** One conversation from an open database (a snapshot, or the writer's own before it is published). */
+export function readConversation(d: Database, id: string, where: Where): Session {
+  const tables = new Set((d.query("SELECT name FROM sqlite_master WHERE type = 'table'").all() as Array<{ name: string }>).map((r) => r.name))
+  if (!tables.has("steps")) throw new Error(`not an Antigravity conversation database (no steps table): ${where.path}`)
+  const count = (d.query("SELECT count(*) AS n FROM steps").get() as { n: number }).n
+  if (count > MAX_STEPS) throw new Error(`Antigravity conversation has ${count} steps, more than ${MAX_STEPS}: ${where.path}`)
+
+  const lost = lossCounter()
+  const turns: Turn[] = []
+
+  // Subagent and battle trajectories are stored beside the conversation's own and are not read.
+  if (tables.has("trajectory_meta")) {
+    const n = (d.query("SELECT count(*) AS n FROM trajectory_meta").get() as { n: number }).n
+    if (n > 1) lost.add("auxiliary trajectories (subagents, battles)", n - 1)
+  }
+  if (tables.has("battle_mode_infos")) {
+    const n = (d.query("SELECT count(*) AS n FROM battle_mode_infos").get() as { n: number }).n
+    if (n) lost.add("battle mode records", n)
+  }
+  let startedAt: string | undefined
+  let metaCwd: string | undefined
+  if (tables.has("trajectory_metadata_blob")) {
+    const row = d.query("SELECT data FROM trajectory_metadata_blob WHERE id = 'main'").get() as { data: unknown } | null
+    if (row?.data instanceof Uint8Array)
+      try {
+        const m = decode(row.data)
+        startedAt = timestampOf(tryMessage(m, 2))
+        metaCwd = pathOfUri(workspaceOf(m))
+      } catch {
+        // Metadata that does not decode only costs the start time and folder.
+      }
+  }
+
+  // Calls waiting for their result: the id the store gave them, and the id they have here.
+  const pending: Array<{ native: string; id: string }> = []
+  const used = new Set<string>()
+  let continued: string | undefined
+  let firstAt: string | undefined
+  let lastAt: string | undefined
+
+  const parseArgs = (args: string): unknown => {
+    if (!args.trim()) return {}
+    try {
+      return JSON.parse(args)
+    } catch {
+      lost.add("unreadable tool arguments")
+      return { arguments: args }
+    }
+  }
+  const call = (at: string | undefined, native: string, name: string, input: unknown, kind = antigravityToolKind(name)) => {
+    let callId = native
+    for (let k = 2; !callId || used.has(callId); k++) callId = `${native || "call"}#${k}`
+    used.add(callId)
+    turns.push({ kind: "tool_call", ...stamp(at), id: callId, name, toolKind: kind, input })
+    return callId
+  }
+  /** The pending call a result answers: the linked one when the step names it, else the oldest. */
+  const take = (link: string | undefined) => {
+    if (link === undefined) return pending.shift()
+    const i = pending.findIndex((p) => p.native === link)
+    return i >= 0 ? pending.splice(i, 1)[0] : undefined
+  }
+  const result = (at: string | undefined, link: Partial<NativeCall> | undefined, fallback: { name: string; input: unknown }, ok: boolean, output: string) => {
+    let callId = take(link?.id)?.id
+    if (!callId) {
+      // A result whose call was not recorded (or not readable): the call is rebuilt from what the step says.
+      callId = call(at, link?.id ?? "", link?.name ?? fallback.name, link?.args !== undefined ? parseArgs(link.args) : fallback.input)
+      lost.add("tool calls rebuilt from their results")
+    }
+    const c = clip(output)
+    turns.push({ kind: "tool_result", ...stamp(at), callId, ok, output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+  }
+
+  const rows = d.query("SELECT idx, step_type, status, has_subtrajectory, metadata, step_payload, step_format FROM steps ORDER BY idx").all() as Array<Record<string, unknown>>
+  for (const r of rows) {
+    const type = Number(r.step_type)
+    const status = Number(r.status)
+    if (Number(r.step_format ?? 0) !== 0) {
+      lost.add("Antigravity steps in an unknown encoding")
+      continue
+    }
+    if (!(r.step_payload instanceof Uint8Array)) {
+      lost.add("unreadable Antigravity steps")
+      continue
+    }
+    let outer: Field[]
+    let body: Field[] | undefined
+    try {
+      outer = decode(r.step_payload)
+      // The row and the serialised step say the same type and status, or the step is not trusted.
+      const t = numberOf(outer, 1)
+      const s = numberOf(outer, 4)
+      if ((t !== undefined && t !== type) || (s !== undefined && s !== status)) throw new Error("step row and payload disagree")
+      const field = PAYLOAD_FIELD[type]
+      const b = field === undefined ? undefined : bytesOf(outer, field)
+      body = b ? decode(b) : undefined
+    } catch {
+      lost.add("unreadable Antigravity steps")
+      continue
+    }
+    if (Number(r.has_subtrajectory) > 0) lost.add("subtrajectories under steps")
+    let meta: Field[] | undefined
+    try {
+      meta = r.metadata instanceof Uint8Array ? decode(r.metadata) : tryMessage(outer, 5)
+    } catch {
+      meta = undefined
+    }
+    const at = timestampOf(tryMessage(meta, 1))
+    if (at) {
+      firstAt ??= at
+      lastAt = at
+    }
+    // A result step's metadata names the call it answers.
+    const linked = tryCall(meta && bytesOf(meta, 4))
+
+    if (!body && (type === STEP.userInput || type === STEP.plannerResponse || type === STEP.generic || type in BUILTIN || type === STEP.mcpTool)) {
+      lost.add("unreadable Antigravity steps")
+      continue
+    }
+    switch (type) {
+      case STEP.userInput: {
+        let text = textOf(body!, 2) || textOf(body!, 1) || ""
+        // The note brain puts before a continued session's first request says where it came from.
+        const note = CONTINUED_NOTE.exec(text)
+        if (note) {
+          continued ??= note[1]
+          text = text.replace(/^\[[^\n]*\]\n*/, "")
+        }
+        const context = allBytes(body!, 3).length + allBytes(body!, 9).length
+        if (context) lost.add("context attached to user messages", context)
+        if (text.trim()) turns.push({ kind: "user", ...stamp(at), text })
+        break
+      }
+      case STEP.plannerResponse: {
+        const thinking = hasThinking(body!)
+        if (thinking) lost.add("private reasoning")
+        const text = textOf(body!, 1) ?? ""
+        if (text.trim()) turns.push({ kind: "assistant", ...stamp(at), text })
+        const calls = allBytes(body!, 7)
+        for (const b of calls) {
+          const c = tryCall(b)
+          if (!c) {
+            lost.add("unreadable tool calls")
+            continue
+          }
+          pending.push({ native: c.id, id: call(at, c.id, c.name, parseArgs(c.args)) })
+        }
+        if (!text.trim() && !calls.length && !thinking) lost.add("Antigravity replies with nothing readable")
+        break
+      }
+      case STEP.generic: {
+        const res = tryMessage(body, 2)
+        if (!res) {
+          lost.add("unreadable Antigravity steps")
+          break
+        }
+        const key = entriesOf(res, 2).find(([k]) => k === LINK_KEY)?.[1]
+        const args = Object.fromEntries(
+          entriesOf(body!, 1).map(([k, v]) => {
+            try {
+              return [k, JSON.parse(v)]
+            } catch {
+              return [k, v]
+            }
+          }),
+        )
+        result(at, key ? { id: key } : linked, { name: "generic", input: args }, status !== STATUS.error, textOf(res, 1) ?? "")
+        break
+      }
+      case STEP.mcpTool: {
+        const c = tryCall(bytesOf(body!, 2))
+        let callId: string | undefined
+        if (c) {
+          const i = pending.findIndex((p) => p.native === c.id)
+          callId = i >= 0 ? pending.splice(i, 1)[0]!.id : call(at, c.id, c.name, parseArgs(c.args), "mcp")
+        }
+        const output = textOf(body!, 3) ?? textOf(body!, 8)
+        if (output === undefined) {
+          lost.add("MCP steps without a readable result")
+          break
+        }
+        callId ??= call(at, "", "mcp_tool", {}, "mcp")
+        const o = clip(output)
+        turns.push({ kind: "tool_result", ...stamp(at), callId, ok: status !== STATUS.error, output: o.text, ...(o.truncated ? { truncated: true } : {}) })
+        break
+      }
+      case STEP.runCommand:
+      case STEP.viewFile:
+      case STEP.shellExec: {
+        const b = builtin(type, body!)
+        result(at, linked, b, status !== STATUS.error, b.output ?? "")
+        break
+      }
+      default: {
+        lost.add(`antigravity step type ${type}`)
+        // A step brain cannot read that answers a pending call still closes it, so the call is not left open.
+        const i = linked ? pending.findIndex((p) => p.native === linked.id) : -1
+        if (i >= 0)
+          turns.push({
+            kind: "tool_result",
+            ...stamp(at),
+            callId: pending.splice(i, 1)[0]!.id,
+            ok: status !== STATUS.error,
+            output: `[Antigravity kept this result in a step type brain cannot read (${type}).]`,
+          })
+      }
+    }
+  }
+
+  const cwd = where.cwd ?? metaCwd
+  const started = startedAt ?? firstAt
+  const updated = where.updatedAt ?? lastAt
+  const parent: SessionHeader["parent"] = continued
+    ? { id: continued, kind: "continued" }
+    : where.parent
+      ? { id: `${TOOL}:${where.parent}`, kind: "subagent" }
+      : undefined
+  const h = header(TOOL, id, {
+    sourcePath: where.path,
+    ...(where.title ? { title: where.title } : {}),
+    project: { ...(cwd ? { cwd } : {}), ...gitInfo(cwd) },
+    ...(started ? { startedAt: started } : {}),
+    ...(updated ? { updatedAt: updated } : {}),
+    ...(parent ? { parent } : {}),
+  })
+  lost.flush(h)
+  return { header: h, turns }
+}

package/src/adapters/antigravity/records.ts

@@ -0,0 +1,236 @@
+import { join } from "node:path"
+import type { ToolKind } from "../../session/types.ts"
+import { toolKindOf } from "../../session/util.ts"
+import { allBytes, asText, concat, decode, messageField, numberOf, textField, textOf, varintField, type Field } from "./proto.ts"
+
+// Antigravity (Google): where its conversations are and what their rows look like. Ported from the clean-room
+// format notes and reference adapter of session-migrate (MIT, xhluca: docs/antigravity-format.md,
+// src/session_migrate/formats/antigravity.py), which pin Antigravity CLI 1.1.16, and checked against the real
+// 1.1.16 capture in test/fixtures/native-corpus/antigravity.
+//
+// Every conversation is its own SQLite database, ~/.gemini/<store>/conversations/<uuid>.db, with seven tables:
+// trajectory_meta (the conversation's trajectory: type 4 cascade, source 17 for the CLI), steps (one row per
+// step, idx 0..n-1, each with its type and status both as columns and inside the serialised Step protobuf),
+// trajectory_metadata_blob (one "main" row), and four runtime tables. Beside the folder,
+// conversation_summaries.db is the picker's index: title, preview, workspace, times. The CLI keeps its store in
+// antigravity-cli; the IDE uses antigravity and antigravity-ide, the same layout, a wider summaries table, and
+// encrypted <uuid>.pb files that nothing here reads.
+//
+// A Step carries its type in field 1, its status in field 4 (3 done, 7 error), its metadata (times, the tool
+// call a result answers) in field 5, and its body in a field that depends on the type (PAYLOAD_FIELD). A user
+// input keeps the person's text in field 2; a planner response keeps the reply in field 1, a message id in
+// field 6 and its tool calls (id 1, name 2, JSON arguments 3) in repeated field 7, and private thinking in
+// fields 3, 4, 14 and 16; a generic tool step keeps the arguments as {key, JSON value} entries in repeated field
+// 1 and the result in field 2 (text in its field 1, {key, value} metadata in its repeated field 2).
+
+export const TOOL = "antigravity"
+export const LABEL = "Antigravity"
+/** Antigravity CLI versions whose store the writer was checked against (by session-migrate's live checks). */
+export const TESTED_VERSIONS = ["1.1.16"]
+
+/** The CLI's store, then the IDE's two. */
+export const STORES = ["antigravity-cli", "antigravity", "antigravity-ide"] as const
+export type Store = (typeof STORES)[number]
+export const CLI_STORE: Store = "antigravity-cli"
+
+export const storeDir = (home: string, store: Store) => join(home, ".gemini", store)
+export const conversationsDir = (home: string, store: Store) => join(storeDir(home, store), "conversations")
+export const summariesPath = (home: string, store: Store) => join(storeDir(home, store), "conversation_summaries.db")
+
+/** A conversation database's file name: its UUID and .db. */
+export const CONVERSATION_FILE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.db$/i
+
+export const STEP = {
+  viewFile: 8,
+  listDirectory: 9,
+  userInput: 14,
+  plannerResponse: 15,
+  runCommand: 21,
+  checkpoint: 23,
+  mcpTool: 38,
+  fileChange: 86,
+  conversationHistory: 98,
+  shellExec: 112,
+  writeBlob: 128,
+  generic: 132,
+} as const
+
+/** The Step field holding each type's body, as observed in 1.1.16. */
+export const PAYLOAD_FIELD: Record<number, number> = { 8: 14, 9: 15, 14: 19, 15: 20, 21: 28, 23: 30, 38: 47, 86: 98, 98: 111, 112: 127, 128: 142, 132: 140 }
+
+export const STATUS = { done: 3, error: 7 } as const
+export const TRAJECTORY = { cascade: 4, cli: 17 } as const
+/** The project the CLI files conversations under when it has no other. */
+export const PROJECT_ID = "default-cli-project"
+/** The generic result's metadata key linking it to its call (session-migrate's, kept for interoperability). */
+export const LINK_KEY = "session_migrate_call_id"
+
+/** Bounds on what a reader accepts from a store. */
+export const MAX_DB_BYTES = 256 * 1024 * 1024
+export const MAX_STEPS = 100_000
+
+/** The conversation database as the 1.1.16 CLI creates it (from the capture's sqlite_master). */
+export const SCHEMA = `
+CREATE TABLE \`trajectory_meta\` (\`trajectory_id\` text,\`cascade_id\` text,\`trajectory_type\` integer,\`source\` integer,PRIMARY KEY (\`trajectory_id\`));
+CREATE TABLE \`steps\` (\`idx\` integer,\`step_type\` integer NOT NULL DEFAULT 0,\`status\` integer NOT NULL DEFAULT 0,\`has_subtrajectory\` numeric NOT NULL DEFAULT false,\`metadata\` blob,\`error_details\` blob,\`permissions\` blob,\`task_details\` blob,\`render_info\` blob,\`step_payload\` blob,\`step_format\` integer NOT NULL DEFAULT 0,PRIMARY KEY (\`idx\`));
+CREATE TABLE \`gen_metadata\` (\`idx\` integer,\`data\` blob,\`size\` integer NOT NULL DEFAULT 0,PRIMARY KEY (\`idx\`));
+CREATE TABLE \`executor_metadata\` (\`idx\` integer,\`data\` blob,PRIMARY KEY (\`idx\`));
+CREATE TABLE \`parent_references\` (\`idx\` integer,\`data\` blob,PRIMARY KEY (\`idx\`));
+CREATE TABLE \`trajectory_metadata_blob\` (\`id\` text DEFAULT "main",\`data\` blob,PRIMARY KEY (\`id\`));
+CREATE TABLE \`battle_mode_infos\` (\`idx\` integer,\`data\` blob,PRIMARY KEY (\`idx\`));
+CREATE INDEX \`idx_steps_status\` ON \`steps\`(\`status\`);
+CREATE INDEX \`idx_steps_step_type\` ON \`steps\`(\`step_type\`);
+`
+
+/** The picker index as 1.1.16 creates it. */
+export const SUMMARY_SCHEMA = `
+CREATE TABLE \`conversation_summaries\` (\`conversation_id\` text,\`title\` text NOT NULL DEFAULT "",\`preview\` text NOT NULL DEFAULT "",\`step_count\` integer NOT NULL DEFAULT 0,\`last_modified_time\` datetime NOT NULL,\`workspace_uris\` text NOT NULL,\`status\` text NOT NULL DEFAULT "",\`source\` text NOT NULL DEFAULT "",\`project_id\` text NOT NULL DEFAULT "",\`agent_name\` text NOT NULL DEFAULT "",\`parent_conversation_id\` text NOT NULL DEFAULT "",\`nesting_depth\` integer NOT NULL DEFAULT 0,\`battle_id\` text NOT NULL DEFAULT "",\`winning_conversation_id\` text NOT NULL DEFAULT "",\`not_fully_idle\` numeric NOT NULL DEFAULT false,\`killed\` numeric NOT NULL DEFAULT false,\`last_user_input_time\` datetime NOT NULL,\`last_user_input_step_index\` integer NOT NULL DEFAULT -1,\`app_data_dir\` text NOT NULL DEFAULT "",PRIMARY KEY (\`conversation_id\`));
+CREATE INDEX \`idx_conversation_summaries_last_user_input_time\` ON \`conversation_summaries\`(\`last_user_input_time\`);
+CREATE INDEX \`idx_conversation_summaries_last_modified_time\` ON \`conversation_summaries\`(\`last_modified_time\`);
+`
+
+/** The summary columns 1.1.16 has, all of which the writer fills. Newer builds and the IDE add more. */
+export const SUMMARY_COLUMNS = [
+  "conversation_id",
+  "title",
+  "preview",
+  "step_count",
+  "last_modified_time",
+  "workspace_uris",
+  "status",
+  "source",
+  "project_id",
+  "agent_name",
+  "parent_conversation_id",
+  "nesting_depth",
+  "battle_id",
+  "winning_conversation_id",
+  "not_fully_idle",
+  "killed",
+  "last_user_input_time",
+  "last_user_input_step_index",
+  "app_data_dir",
+] as const
+
+/** A google.protobuf.Timestamp ({1: seconds, 2: nanos}) as ISO time. */
+export function timestampOf(fields: Field[] | undefined): string | undefined {
+  const seconds = fields && numberOf(fields, 1)
+  if (!seconds || seconds <= 0) return undefined
+  const nanos = numberOf(fields!, 2) ?? 0
+  const ms = seconds * 1000 + Math.floor(nanos / 1e6)
+  return Number.isFinite(ms) && ms < 8.64e15 ? new Date(ms).toISOString() : undefined
+}
+
+/** A summaries datetime ("2026-09-01 00:08:05.04913412+00:00", as Go writes it) as ISO time; Go's zero time is none. */
+export function sqlTime(v: unknown): string | undefined {
+  if (typeof v !== "string") return undefined
+  const m = /^(\d{4}-\d\d-\d\d)[ T](\d\d:\d\d:\d\d)(?:\.(\d+))?\s*(Z|[+-]\d\d:?\d\d)?$/.exec(v.trim())
+  if (!m || m[1]!.startsWith("0001-")) return undefined
+  const frac = (m[3] ?? "").slice(0, 3).padEnd(3, "0")
+  const t = Date.parse(`${m[1]}T${m[2]}.${frac}${m[4] ?? "Z"}`)
+  return Number.isFinite(t) ? new Date(t).toISOString() : undefined
+}
+
+/** A time as the summaries table stores it. */
+export const toSqlTime = (d: Date) => `${d.toISOString().slice(0, 10)} ${d.toISOString().slice(11, 23)}+00:00`
+
+/** A tool call as a planner response stores it. */
+export interface NativeCall {
+  id: string
+  name: string
+  /** The arguments JSON as stored. */
+  args: string
+}
+
+export function decodeCall(b: Uint8Array): NativeCall | undefined {
+  const f = decode(b)
+  const id = textOf(f, 1)
+  const name = textOf(f, 2)
+  if (!id || !name) return undefined
+  return { id, name, args: textOf(f, 3) ?? "" }
+}
+
+/** Whether a planner response holds private thinking (visible or raw thinking, a signature, or the thinking flag). */
+export const hasThinking = (planner: Field[]) => [3, 4, 14, 16].some((n) => allBytes(planner, n).length > 0) || numberOf(planner, 5) === 1
+
+/** The {key, value} entries of a repeated map field. */
+export function entriesOf(fields: Field[], no: number): Array<[string, string]> {
+  const out: Array<[string, string]> = []
+  for (const e of allBytes(fields, no)) {
+    try {
+      const f = decode(e)
+      const k = textOf(f, 1)
+      if (k !== undefined) out.push([k, textOf(f, 2) ?? ""])
+    } catch {
+      // An entry that is not a {key, value} message is skipped.
+    }
+  }
+  return out
+}
+
+/** What Antigravity's own tools do; other names go through the shared guess. */
+const KINDS: Record<string, ToolKind> = {
+  view_file: "read",
+  view_file_outline: "read",
+  view_code_item: "read",
+  list_dir: "list",
+  find_by_name: "search",
+  grep_search: "search",
+  codebase_search: "search",
+  run_command: "shell",
+  command_status: "shell",
+  send_command_input: "shell",
+  shell_exec: "shell",
+  write_to_file: "write",
+  replace_file_content: "edit",
+  multi_replace_file_content: "edit",
+  read_url_content: "web",
+  search_web: "web",
+}
+export const antigravityToolKind = (name: string): ToolKind => KINDS[name] ?? toolKindOf(name)
+
+// Encoding the four messages the writer emits.
+
+const uuidText = (no: number, id: string) => textField(no, id)
+
+/** A whole Step: type, status, and the body in its type's field. */
+export function stepBytes(type: number, status: number, body: Uint8Array): Uint8Array {
+  const field = PAYLOAD_FIELD[type]
+  if (field === undefined) throw new Error(`no payload field is known for Antigravity step type ${type}`)
+  return concat([varintField(1, type), varintField(4, status), messageField(field, [body])])
+}
+
+export const userInputBody = (text: string) => textField(2, text)
+
+export function plannerBody(o: { text?: string; messageId: string; calls?: NativeCall[] }): Uint8Array {
+  return concat([
+    ...(o.text ? [textField(1, o.text)] : []),
+    uuidText(6, o.messageId),
+    ...(o.calls ?? []).map((c) => messageField(7, [textField(1, c.id), textField(2, c.name), textField(3, c.args)])),
+  ])
+}
+
+export function genericBody(o: { args: Array<[string, string]>; result: string; callId: string }): Uint8Array {
+  return concat([
+    ...o.args.map(([k, v]) => messageField(1, [textField(1, k), textField(2, v)])),
+    messageField(2, [textField(1, o.result), messageField(2, [textField(1, LINK_KEY), textField(2, o.callId)])]),
+  ])
+}
+
+/** The minimal "main" trajectory metadata: creation time, root conversation id, project. */
+export const trajectoryMetadata = (seconds: number, conversationId: string) =>
+  concat([messageField(2, [varintField(1, seconds)]), textField(6, conversationId), textField(18, PROJECT_ID)])
+
+/** The first workspace folder in trajectory metadata (field 1's folder URI, else field 7). */
+export function workspaceOf(meta: Field[]): string | undefined {
+  for (const w of allBytes(meta, 1)) {
+    try {
+      const uri = textOf(decode(w), 1)
+      if (uri) return uri
+    } catch {
+      // not a workspace message
+    }
+  }
+  const first = allBytes(meta, 7)[0]
+  return first ? asText(first) : undefined
+}