@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/antigravity/proto.ts

@@ -0,0 +1,194 @@
+// A small, bounded protobuf wire codec: enough to read and write the few Antigravity messages brain needs,
+// with no generated classes and no descriptors. It takes varints (canonical, at most 64 bits), fixed64,
+// length-delimited values and fixed32; it rejects groups and unknown wire types, caps every length and the
+// number of fields in one message, and never recurses on its own (callers decode nested messages they know).
+// Ported from the wire subset session-migrate (MIT, xhluca) pins for Antigravity CLI 1.1.16.
+
+export const WIRE = { varint: 0, fixed64: 1, bytes: 2, fixed32: 5 } as const
+
+export interface Field {
+  no: number
+  wire: 0 | 1 | 2 | 5
+  /** A varint as a number when it is a safe integer, else a bigint; raw bytes for the other wire types. */
+  value: number | bigint | Uint8Array
+}
+
+export interface Limits {
+  /** Longest length-delimited value, and longest message. */
+  maxBytes: number
+  /** Most fields in one message. */
+  maxFields: number
+}
+
+export const LIMITS: Limits = { maxBytes: 64 * 1024 * 1024, maxFields: 100_000 }
+
+export class ProtoError extends Error {
+  constructor(why: string) {
+    super(`protobuf: ${why}`)
+  }
+}
+
+const MAX_FIELD_NO = 536_870_911
+
+/** A varint at `at`: its value and where the next byte is. Rejects truncated, over-long and non-canonical encodings. */
+function readVarint(b: Uint8Array, at: number): [bigint, number] {
+  let v = 0n
+  for (let i = 0; i < 10; i++) {
+    if (at >= b.length) throw new ProtoError("varint is truncated")
+    const byte = b[at++]!
+    if (i === 9 && byte > 1) throw new ProtoError("varint exceeds 64 bits")
+    v |= BigInt(byte & 0x7f) << BigInt(7 * i)
+    if (byte < 0x80) {
+      // Canonical: no trailing zero byte (0x80 0x00 is 0 written long).
+      if (i > 0 && byte === 0) throw new ProtoError("varint is not canonical")
+      return [v, at]
+    }
+  }
+  throw new ProtoError("varint exceeds 64 bits")
+}
+
+const small = (v: bigint): number | bigint => (v <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(v) : v)
+
+/** The fields of one message, in wire order. Throws ProtoError on anything outside the subset or the limits. */
+export function decode(b: Uint8Array, limits: Limits = LIMITS): Field[] {
+  if (b.length > limits.maxBytes) throw new ProtoError("message exceeds the size limit")
+  const out: Field[] = []
+  let at = 0
+  while (at < b.length) {
+    if (out.length >= limits.maxFields) throw new ProtoError("message has too many fields")
+    const [key, next] = readVarint(b, at)
+    at = next
+    const no = Number(key >> 3n)
+    const wire = Number(key & 7n)
+    if (no <= 0 || no > MAX_FIELD_NO) throw new ProtoError(`invalid field number ${no}`)
+    switch (wire) {
+      case 0: {
+        const [v, n] = readVarint(b, at)
+        at = n
+        out.push({ no, wire: 0, value: small(v) })
+        break
+      }
+      case 1:
+      case 5: {
+        const size = wire === 1 ? 8 : 4
+        if (at + size > b.length) throw new ProtoError(`fixed${size * 8} value is truncated`)
+        out.push({ no, wire, value: b.slice(at, at + size) })
+        at += size
+        break
+      }
+      case 2: {
+        const [len, n] = readVarint(b, at)
+        at = n
+        if (len > BigInt(limits.maxBytes)) throw new ProtoError("value exceeds the size limit")
+        const end = at + Number(len)
+        if (end > b.length) throw new ProtoError("length-delimited value is truncated")
+        out.push({ no, wire: 2, value: b.slice(at, end) })
+        at = end
+        break
+      }
+      case 3:
+      case 4:
+        throw new ProtoError("groups are not supported")
+      default:
+        throw new ProtoError(`unknown wire type ${wire}`)
+    }
+  }
+  return out
+}
+
+// Encoding.
+
+function varintBytes(v: number | bigint): Uint8Array {
+  if (typeof v === "number" && (!Number.isSafeInteger(v) || v < 0)) throw new ProtoError("cannot encode a negative, fractional or unsafe varint")
+  let n = typeof v === "bigint" ? v : BigInt(v)
+  if (n < 0n || n >= 1n << 64n) throw new ProtoError("varint out of range")
+  const out: number[] = []
+  while (n >= 0x80n) {
+    out.push(Number(n & 0x7fn) | 0x80)
+    n >>= 7n
+  }
+  out.push(Number(n))
+  return Uint8Array.from(out)
+}
+
+export function concat(parts: Uint8Array[]): Uint8Array {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0))
+  let at = 0
+  for (const p of parts) {
+    out.set(p, at)
+    at += p.length
+  }
+  return out
+}
+
+const key = (no: number, wire: number) => {
+  if (!Number.isInteger(no) || no <= 0 || no > MAX_FIELD_NO) throw new ProtoError(`invalid field number ${no}`)
+  return varintBytes(BigInt(no) * 8n + BigInt(wire))
+}
+
+export const varintField = (no: number, v: number | bigint) => concat([key(no, 0), varintBytes(v)])
+
+export function bytesField(no: number, v: Uint8Array, limits: Limits = LIMITS): Uint8Array {
+  if (v.length > limits.maxBytes) throw new ProtoError("value exceeds the size limit")
+  return concat([key(no, 2), varintBytes(v.length), v])
+}
+
+export const textField = (no: number, s: string) => bytesField(no, new TextEncoder().encode(s))
+
+/** A nested message as a length-delimited field. */
+export const messageField = (no: number, parts: Uint8Array[]) => bytesField(no, concat(parts))
+
+export function fixedField(no: number, v: Uint8Array): Uint8Array {
+  if (v.length !== 4 && v.length !== 8) throw new ProtoError("a fixed value is 4 or 8 bytes")
+  return concat([key(no, v.length === 8 ? 1 : 5), v])
+}
+
+/** Decoded fields back to bytes: encode(decode(b)) is b for any canonical message. */
+export function encode(fields: Field[]): Uint8Array {
+  return concat(
+    fields.map((f) => {
+      if (f.wire === 0) return varintField(f.no, f.value as number | bigint)
+      if (f.wire === 2) return bytesField(f.no, f.value as Uint8Array)
+      return fixedField(f.no, f.value as Uint8Array)
+    }),
+  )
+}
+
+// Reading fields. Protobuf lets a singular field repeat (the last one wins), so these take the last.
+
+const last = (fields: Field[], no: number, wire: number) => {
+  for (let i = fields.length - 1; i >= 0; i--) if (fields[i]!.no === no && fields[i]!.wire === wire) return fields[i]!
+  return undefined
+}
+
+/** Every length-delimited value of a repeated field, in order. */
+export const allBytes = (fields: Field[], no: number): Uint8Array[] => fields.filter((f) => f.no === no && f.wire === 2).map((f) => f.value as Uint8Array)
+
+export const bytesOf = (fields: Field[], no: number): Uint8Array | undefined => last(fields, no, 2)?.value as Uint8Array | undefined
+
+export function numberOf(fields: Field[], no: number): number | undefined {
+  const v = last(fields, no, 0)?.value
+  return v === undefined ? undefined : Number(v)
+}
+
+const utf8 = new TextDecoder("utf-8", { fatal: true })
+
+/** A value as UTF-8 text; undefined when absent or not valid UTF-8. */
+export function textOf(fields: Field[], no: number): string | undefined {
+  const b = bytesOf(fields, no)
+  return b === undefined ? undefined : asText(b)
+}
+
+export function asText(b: Uint8Array): string | undefined {
+  try {
+    return utf8.decode(b)
+  } catch {
+    return undefined
+  }
+}
+
+/** A nested message, decoded; undefined when absent. */
+export function messageOf(fields: Field[], no: number, limits: Limits = LIMITS): Field[] | undefined {
+  const b = bytesOf(fields, no)
+  return b === undefined ? undefined : decode(b, limits)
+}

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 }
+}