@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/goose/records.ts

@@ -0,0 +1,199 @@
+import { join } from "node:path"
+import { versionOf } from "../../fsutil.ts"
+import type { Session, ToolKind, Turn, Usage } from "../../session/types.ts"
+import { asText, clip, iso, lossCounter, noteModel, toolKindOf } from "../../session/util.ts"
+import { CONTINUED_NOTE } from "../claude-code/records.ts"
+
+// What Goose's sessions look like, shared by the reader and the writer. Checked against goose v1.57.0's
+// source (crates/goose/src/session/session_manager.rs, import_formats/, goose-provider-types
+// conversation/message.rs and tool_result_serde.rs, context_mgmt/mod.rs) and against rows the 1.57.0
+// binary wrote itself into a temporary home. Catalogue: docs/sessions/2026-11-08-session-formats.md, "Goose".
+//
+// Since 1.10 every session is a row of ~/.local/share/goose/sessions/sessions.db (schema version 17 in
+// 1.57.0) and every message a row whose content_json is the message's list of typed blocks. Before that a
+// session was <YYYYMMDD_HHMMSS>.jsonl in the same folder: a metadata line, then one message per line. Goose
+// copies those files into the database the first time it creates it, so they are read only when there is
+// no database yet.
+
+export const TOOL = "goose"
+export const LABEL = "Goose"
+
+/** Goose versions whose session JSON and import the writer was checked against. */
+export const TESTED_VERSIONS = ["1.57.0"]
+
+export const sessionsDir = (home: string) => join(home, ".local", "share", "goose", "sessions")
+export const dbPath = (home: string) => join(sessionsDir(home), "sessions.db")
+
+/** "1.57.0" from `goose --version` (which prints " 1.57.0"); undefined when goose is missing. */
+export const gooseVersion = (bin = "goose") => versionOf(bin)?.match(/\d+\.\d+\.\d+/)?.[0]
+
+/** The text Goose puts after its own compaction summary (context_mgmt CONVERSATION_CONTINUATION_TEXT). */
+export const CONTINUATION_TEXT =
+  "Your context was compacted. The previous message contains a summary of the conversation so far.\nDo not mention that you read a summary or that conversation summarization occurred.\nJust continue the conversation naturally based on the summarized context."
+
+/** One message as Goose serialises it (Message in goose-provider-types, camelCase). */
+export interface GooseMessage {
+  id?: string | null
+  role: string
+  created: number
+  content: Array<Record<string, any>>
+  metadata?: {
+    userVisible?: boolean
+    agentVisible?: boolean
+    turnContext?: boolean
+    inference?: { provider?: string; requestedModel?: string; resolvedModel?: string }
+    usage?: { inputTokens?: number; outputTokens?: number; cacheReadTokens?: number; cacheWriteTokens?: number }
+    [k: string]: unknown
+  }
+}
+
+/**
+ * What a Goose tool does. Goose names a tool `<extension>__<tool>`; the developer extension's are shell,
+ * write, edit, tree and read_image in 1.57, and text_editor (with a `command`) in older versions.
+ */
+export function gooseToolKind(name: string, input: unknown): ToolKind {
+  const short = name.includes("__") ? name.slice(name.lastIndexOf("__") + 2) : name
+  if (short === "tree") return "list"
+  if (short === "read_image") return "read"
+  if (short === "text_editor") {
+    const command = (input as { command?: unknown } | null)?.command
+    return command === "view" ? "read" : command === "write" ? "write" : "edit"
+  }
+  return toolKindOf(short)
+}
+
+/** The text of a tool result's content blocks (MCP CallToolResult content), and how many images it held. */
+function resultText(content: unknown): { text: string; images: number } {
+  if (!Array.isArray(content)) return { text: asText(content), images: 0 }
+  const parts: string[] = []
+  let images = 0
+  for (const c of content as Array<Record<string, any>>) {
+    if (c?.type === "text" && typeof c.text === "string") parts.push(c.text)
+    else if (c?.type === "image") images++
+    else if (c?.type === "resource" && typeof c.resource?.text === "string") parts.push(c.resource.text)
+    else parts.push(asText(c))
+  }
+  return { text: parts.join("\n"), images }
+}
+
+/** Goose stores a failed call as the error's Display, "-32603: <message>", sometimes twice over. */
+const errorText = (e: unknown) => asText(e).replace(/^(?:-?\d+: )+/, "")
+
+const visible = (m: GooseMessage) => ({ user: m.metadata?.userVisible !== false, agent: m.metadata?.agentVisible !== false })
+
+/**
+ * The portable turns of a Goose conversation. Messages the person saw are the history (including those a
+ * compaction hid from the model); an agent-only user message after them is Goose's compaction summary;
+ * Goose's own continuation text and per-turn context are not conversation. Returns the id of the session a
+ * brain-written conversation continues, when its note is there.
+ */
+export function turnsOf(messages: GooseMessage[], h: Session["header"]): { turns: Turn[]; continued?: string } {
+  const turns: Turn[] = []
+  const lost = lossCounter()
+  let continued: string | undefined
+  let hiddenBefore = false
+  const isContinuation = (m: GooseMessage | undefined) =>
+    m?.role === "assistant" && m.metadata?.userVisible === false && m.content?.some((b) => typeof b?.text === "string" && b.text.startsWith("Your context was compacted"))
+  for (const [idx, m] of messages.entries()) {
+    const at = iso(m.created)
+    const stamp = at ? { at } : {}
+    const v = visible(m)
+    const content = Array.isArray(m.content) ? m.content : []
+    const texts = content.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text as string)
+    if (!v.user && !v.agent) continue
+    if (m.metadata?.turnContext) continue
+    if (!v.user) {
+      const text = texts.join("\n")
+      const note = text.match(CONTINUED_NOTE)
+      if (note) continued = note[1]
+      else if (m.role === "user" && (hiddenBefore || isContinuation(messages[idx + 1])) && text.trim()) turns.push({ kind: "compaction", ...stamp, summary: text })
+      else if (!text.startsWith("Your context was compacted")) lost.add("Goose context messages (not carried)")
+      continue
+    }
+    if (!v.agent) hiddenBefore = true
+    const model = m.metadata?.inference?.resolvedModel ?? m.metadata?.inference?.requestedModel
+    if (m.role === "assistant") noteModel(h, model)
+    let usage: Usage | undefined
+    const u = m.metadata?.usage
+    if (u && m.role === "assistant")
+      usage = {
+        ...(u.inputTokens !== undefined ? { input: u.inputTokens } : {}),
+        ...(u.outputTokens !== undefined ? { output: u.outputTokens } : {}),
+        ...(u.cacheReadTokens !== undefined ? { cacheRead: u.cacheReadTokens } : {}),
+        ...(u.cacheWriteTokens !== undefined ? { cacheWrite: u.cacheWriteTokens } : {}),
+      }
+    let text = ""
+    const flushText = () => {
+      if (!text.trim()) return (text = "")
+      if (m.role === "user") turns.push({ kind: "user", ...stamp, text })
+      else {
+        turns.push({ kind: "assistant", ...stamp, text, ...(model ? { model } : {}), ...(usage ? { usage } : {}) })
+        usage = undefined
+      }
+      text = ""
+    }
+    for (const b of content) {
+      switch (b?.type) {
+        case "text":
+          text += (text ? "\n" : "") + String(b.text ?? "")
+          break
+        case "thinking":
+          flushText()
+          // Goose keeps Claude's signature beside the text; the text itself is readable.
+          if (typeof b.thinking === "string" && b.thinking.trim()) turns.push({ kind: "reasoning", ...stamp, text: b.thinking })
+          break
+        case "redactedThinking":
+          lost.add("redacted reasoning")
+          break
+        case "toolRequest": {
+          flushText()
+          const call = b.toolCall ?? {}
+          if (call.status === "success" && call.value && typeof call.value.name === "string") {
+            const input = call.value.arguments ?? {}
+            turns.push({ kind: "tool_call", ...stamp, id: String(b.id), name: call.value.name, toolKind: gooseToolKind(call.value.name, input), input })
+          } else {
+            // The model asked for a call Goose could not parse; the error is all there is.
+            turns.push({ kind: "tool_call", ...stamp, id: String(b.id), name: "invalid_tool_call", toolKind: "other", input: { error: errorText(call.error) } })
+          }
+          break
+        }
+        case "toolResponse": {
+          flushText()
+          const r = b.toolResult ?? {}
+          let output: string
+          let ok: boolean
+          if (r.status === "success") {
+            const value = Array.isArray(r.value) ? { content: r.value } : (r.value ?? {})
+            const { text: out, images } = resultText(value.content)
+            if (images) lost.add("images in tool results", images)
+            output = out
+            ok = value.isError !== true
+          } else {
+            output = errorText(r.error)
+            ok = false
+          }
+          const c = clip(output)
+          turns.push({ kind: "tool_result", ...stamp, callId: String(b.id), ok, output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+          break
+        }
+        case "image":
+          lost.add("images")
+          break
+        case "document":
+          lost.add("documents")
+          break
+        case "toolConfirmationRequest":
+        case "actionRequired":
+        case "systemNotification":
+        case "error":
+          // Prompts and notices Goose shows while it works; not part of the conversation.
+          break
+        default:
+          lost.add(`unknown content types: ${String(b?.type)}`)
+      }
+    }
+    flushText()
+  }
+  lost.flush(h)
+  return { turns, ...(continued ? { continued } : {}) }
+}

package/src/adapters/goose/writer.ts

@@ -0,0 +1,340 @@
+import { copyFileSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
+import { dirname, extname, join, resolve } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { countTurns, firstUserText, unpaired } from "../../session/util.ts"
+import { continuedNote } from "../claude-code/records.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { gooseReader } from "./reader.ts"
+import { CONTINUATION_TEXT, type GooseMessage, LABEL, TESTED_VERSIONS, TOOL, dbPath, gooseVersion } from "./records.ts"
+
+// Continues a portable session in Goose through Goose's own importer: the session is written as the JSON
+// `goose session export --format json` produces (the shape import_formats::build_session_json builds), and
+// `goose session import <file>` stores it as a new session, with an id Goose picks itself (YYYYMMDD_N),
+// in Goose's own transaction. That is safer than inserting rows: Goose migrates its schema, allocates the
+// id and writes with its own locking, so it works while Goose Desktop is open and before the database exists.
+//
+// Tool calls stay structural: toolRequest blocks in an assistant message, answered by toolResponse blocks
+// in the next user message, as Goose writes them. Shell, write and edit calls are mapped onto Goose's
+// developer tools (developer__shell, __write, __edit) when their arguments say what Goose needs; others keep
+// their names. Readable reasoning stays as an unsigned thinking block, which Goose itself makes of plain
+// reasoning. A compaction is written the way Goose compacts: the turns before it stay on screen but hidden
+// from the model, then the summary and Goose's continuation text, visible to the model only. The note
+// saying where the session came from is a model-only message too, so it is never shown as the person's words.
+
+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
+const NO_RESULT = "No result was recorded for this call; the session moved before it finished."
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+type Call = Extract<Turn, { kind: "tool_call" }>
+type Meta = NonNullable<GooseMessage["metadata"]>
+const SHOWN: Meta = { userVisible: true, agentVisible: true }
+const MODEL_ONLY: Meta = { userVisible: false, agentVisible: true }
+const SCREEN_ONLY: Meta = { userVisible: true, agentVisible: false }
+const NEITHER: Meta = { userVisible: false, agentVisible: false }
+
+const str = (v: unknown) => (typeof v === "string" ? v : undefined)
+
+/** A call as Goose's developer extension would have made it, when the arguments carry what Goose needs. */
+export function gooseCall(c: Call): { name: string; args: Record<string, unknown> } | undefined {
+  const i = (c.input && typeof c.input === "object" && !Array.isArray(c.input) ? c.input : {}) as Record<string, unknown>
+  const path = str(i.file_path) ?? str(i.path) ?? str(i.filePath) ?? str(i.target_file) ?? str(i.absolute_path)
+  if (c.toolKind === "shell") {
+    const command = str(i.command) ?? str(i.cmd) ?? (Array.isArray(i.command) ? (i.command as unknown[]).map(String).join(" ") : undefined)
+    return command ? { name: "developer__shell", args: { command } } : undefined
+  }
+  if (c.toolKind === "write") {
+    const content = str(i.content) ?? str(i.file_text) ?? str(i.contents)
+    return path && content !== undefined ? { name: "developer__write", args: { path, content } } : undefined
+  }
+  if (c.toolKind === "edit") {
+    const before = str(i.old_string) ?? str(i.old_str) ?? str(i.oldText)
+    const after = str(i.new_string) ?? str(i.new_str) ?? str(i.newText)
+    return path && before !== undefined && after !== undefined ? { name: "developer__edit", args: { path, before, after } } : undefined
+  }
+  return undefined
+}
+
+export interface GoosePlan {
+  /** The session JSON `goose session import` takes. */
+  json: Record<string, unknown>
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+}
+
+/** The import JSON for `session` continued in `cwd`. Pure apart from reading attached images. */
+export function planGooseSession(session: Session, opts: { cwd: string; now: Date }): GoosePlan {
+  const drops = new Map<string, number>()
+  const drop = (what: string, n = 1) => drops.set(what, (drops.get(what) ?? 0) + n)
+  const label = toolLabel(session.header.tool)
+  const turns = session.turns
+  const lastCompaction = turns.map((t) => t.kind).lastIndexOf("compaction")
+  const expect = { users: 0, assistants: 0, calls: 0 }
+
+  // Which calls are answered somewhere, so the ones that never are can be closed where they stand.
+  const answered = new Set(turns.filter((t) => t.kind === "tool_result").map((t) => (t as Extract<Turn, { kind: "tool_result" }>).callId))
+
+  // Tool call ids: providers take [A-Za-z0-9_-]; others are mapped once, the same way for call and result.
+  const ids = new Map<string, string>()
+  const used = new Set<string>()
+  let remapped = 0
+  const callId = (id: string) => {
+    let v = ids.get(id)
+    if (v) return v
+    const base = /^[A-Za-z0-9_-]{1,64}$/.test(id) ? id : `call_${id.replace(/[^A-Za-z0-9]/g, "").slice(-40) || "x"}`
+    v = base
+    for (let n = 2; used.has(v); n++) v = `${base}_${n}`
+    ids.set(id, v)
+    used.add(v)
+    if (v !== id) remapped++
+    return v
+  }
+  let renamed = 0
+  const toolName = (name: string) => {
+    const v = name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 64) || "tool"
+    if (v !== name) renamed++
+    return v
+  }
+
+  // Message times are seconds and never go backwards: Goose orders a conversation by them.
+  const known = turns.map((t) => (t.at ? Date.parse(t.at) : Number.NaN)).find(Number.isFinite)
+  let clock = Math.floor((known ?? opts.now.getTime()) / 1000)
+  const created = (at?: string) => {
+    const t = at ? Math.floor(Date.parse(at) / 1000) : Number.NaN
+    if (Number.isFinite(t) && t > clock) clock = t
+    return clock
+  }
+
+  const out: GooseMessage[] = []
+  /** Set when the next block must open a new message even if the last one has the same role. */
+  let split = false
+  /** Adds a block to the last message when it has the same role, visibility and kind, else opens a new one. */
+  const add = (role: "user" | "assistant", block: Record<string, unknown>, meta: Meta, at?: string) => {
+    const last = out[out.length - 1]
+    const results = block.type === "toolResponse"
+    const same =
+      !split &&
+      last &&
+      last.role === role &&
+      last.metadata?.userVisible === meta.userVisible &&
+      last.metadata?.agentVisible === meta.agentVisible &&
+      (role === "assistant" || last.content.every((b) => (b.type === "toolResponse") === results))
+    split = false
+    if (same) last.content.push(block)
+    else out.push({ id: null, role, created: created(at), content: [block], metadata: { ...meta } })
+  }
+  const assistantHasCalls = () => {
+    const last = out[out.length - 1]
+    return last?.role === "assistant" && last.content.some((b) => b.type === "toolRequest")
+  }
+  const response = (id: string, ok: boolean, output: string, meta: Meta, at?: string) =>
+    add("user", { type: "toolResponse", id: callId(id), toolResult: { status: "success", value: { content: [{ type: "text", text: output || "(no output)" }], isError: !ok } } }, meta, at)
+
+  add("user", { type: "text", text: continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10)) }, MODEL_ONLY, turns[0]?.at)
+  const written = new Set<string>()
+  const done = new Set<string>()
+
+  for (const [i, t] of turns.entries()) {
+    const meta = i < lastCompaction ? SCREEN_ONLY : SHOWN
+    switch (t.kind) {
+      case "user": {
+        const blocks: Array<Record<string, unknown>> = []
+        let text = t.text
+        for (const a of t.attachments ?? []) {
+          if (!a.path) continue // bytes the reader could not keep; it already counted them
+          if (a.kind === "file") {
+            text += `\n\n[Attached file: ${a.path}]`
+            continue
+          }
+          const mime = a.mime ?? IMAGE_TYPES[extname(a.path).toLowerCase()]
+          let size = Number.POSITIVE_INFINITY
+          try {
+            size = statSync(a.path).size
+          } catch {}
+          if (mime && Object.values(IMAGE_TYPES).includes(mime) && size <= IMAGE_LIMIT) blocks.push({ type: "image", data: readFileSync(a.path).toString("base64"), mimeType: mime })
+          else drop("images that could not be attached")
+        }
+        if (!text.trim() && !blocks.length) break
+        out.push({ id: null, role: "user", created: created(t.at), content: [{ type: "text", text: text.trim() ? text : "(image)" }, ...blocks], metadata: { ...meta } })
+        expect.users++
+        break
+      }
+      case "assistant":
+        if (!t.text.trim()) break
+        // Text after a tool call was written after its result came back: a new message.
+        if (assistantHasCalls()) split = true
+        add("assistant", { type: "text", text: t.text }, meta, t.at)
+        expect.assistants++
+        break
+      case "reasoning":
+        if (!t.text.trim()) break
+        if (assistantHasCalls()) split = true
+        // Goose keeps plain reasoning as thinking without a signature (it migrates `reasoning` blocks so).
+        add("assistant", { type: "thinking", thinking: t.text, signature: "" }, meta, t.at)
+        break
+      case "tool_call": {
+        if (written.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        written.add(t.id)
+        const mapped = gooseCall(t)
+        const args = mapped?.args ?? (t.input && typeof t.input === "object" && !Array.isArray(t.input) ? t.input : { input: t.input ?? null })
+        add("assistant", { type: "toolRequest", id: callId(t.id), toolCall: { status: "success", value: { name: mapped?.name ?? toolName(t.name), arguments: args } } }, meta, t.at)
+        expect.calls++
+        if (!answered.has(t.id)) {
+          response(t.id, false, NO_RESULT, meta, t.at)
+          done.add(t.id)
+          drop("tool calls without a result (closed as errors)")
+        }
+        break
+      }
+      case "tool_result": {
+        if (!written.has(t.callId)) {
+          drop("tool results without a call")
+          break
+        }
+        if (done.has(t.callId)) {
+          drop("repeated tool results")
+          break
+        }
+        done.add(t.callId)
+        response(t.callId, t.ok, t.fullPath ? `${t.output}\n\n[Full output: ${t.fullPath}]` : t.output, meta, t.at)
+        break
+      }
+      case "compaction": {
+        const summary = `[Summary of the earlier conversation in ${label}, which replaced the turns before it]\n\n${t.summary}`
+        if (i === lastCompaction) {
+          add("user", { type: "text", text: summary }, MODEL_ONLY, t.at)
+          add("assistant", { type: "text", text: CONTINUATION_TEXT }, MODEL_ONLY, t.at)
+        } else add("user", { type: "text", text: summary }, NEITHER, t.at)
+        break
+      }
+      case "file_edit":
+        if (!t.callId || !written.has(t.callId)) drop("file edits outside a tool call")
+        break
+      case "subagent":
+        drop("subagent transcripts (their results stay in the parent's tool results)")
+        break
+    }
+  }
+  const conversation = out
+
+  const title = session.header.title ?? firstUserText(session)?.replace(/\s+/g, " ").trim().slice(0, 60) ?? "Session"
+  const first = new Date((conversation[0]?.created ?? Math.floor(opts.now.getTime() / 1000)) * 1000).toISOString()
+  const last = new Date((conversation[conversation.length - 1]?.created ?? Math.floor(opts.now.getTime() / 1000)) * 1000).toISOString()
+  const usage = { input_tokens: null, output_tokens: null, total_tokens: null, cache_read_input_tokens: null, cache_write_input_tokens: null }
+  const json = {
+    id: "imported",
+    working_dir: opts.cwd,
+    name: `${title} (from ${label})`,
+    user_set_name: true,
+    session_type: "user",
+    created_at: first,
+    updated_at: last,
+    extension_data: {},
+    usage,
+    accumulated_usage: usage,
+    accumulated_cost: null,
+    schedule_id: null,
+    recipe: null,
+    user_recipe_values: null,
+    conversation,
+    message_count: conversation.filter((m) => m.metadata?.userVisible !== false).length,
+    provider_name: null,
+    model_config: null,
+    goose_mode: "auto",
+    archived_at: null,
+    project_id: null,
+  }
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  if (remapped) lost.push(`tool call ids, remapped to ids providers accept (${remapped})`)
+  if (renamed) lost.push(`tool names changed to fit Goose (${renamed})`)
+  return { json, lost, expect }
+}
+
+/** The goose binary: the installer's ~/.local/bin/goose first, else whatever is on PATH. */
+function resolveBin(home: string): { path: string; command: string } {
+  const own = join(home, ".local", "bin", "goose")
+  if (exists(own)) return { path: own, command: Bun.which("goose") === own ? "goose" : own }
+  return { path: "goose", command: "goose" }
+}
+
+const stamp = (d: Date) => d.toISOString().replace(/[:.]/g, "-")
+
+/** The Goose writer; `bin` and `version` are for tests, which must not depend on an installed Goose. */
+export function gooseWriter(opts: { bin?: string; version?: string } = {}): Writer {
+  const binFor = (home: string) => (opts.bin ? { path: opts.bin, command: opts.bin } : resolveBin(home))
+  const installed = (home: string) => opts.version ?? gooseVersion(binFor(home).path)
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "import",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed(w.home)
+      if (!v) return { ok: false, why: "Goose is not installed (`goose --version` did not run)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Goose ${v} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+      if (!isDir(w.cwd)) return { ok: false, why: `the folder to continue in does not exist: ${w.cwd}` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const now = new Date()
+      const cwd = resolve(w.cwd)
+      const plan = planGooseSession(session, { cwd, now })
+      const file = join(w.home, ".brain", "exports", `goose-${stamp(now)}.json`)
+      const db = dbPath(w.home)
+      const bin = binFor(w.home)
+      if (w.dryRun)
+        return {
+          tool: TOOL,
+          way: "import",
+          written: [file, db],
+          open: `cd ${shellQuote(cwd)} && ${shellQuote(bin.command)} session import ${shellQuote(file)}, then ${shellQuote(bin.command)} session --resume --session-id <the id it prints> --history`,
+          lost: plan.lost,
+          dryRun: true,
+        }
+
+      mkdirSync(dirname(file), { recursive: true })
+      writeFileSync(file, `${JSON.stringify(plan.json, null, 2)}\n`, { flag: "wx" })
+      // Goose writes the rows itself; a copy of the database as it was comes first all the same.
+      if (exists(db)) {
+        const backup = join(w.home, ".brain", "backups", TOOL, stamp(now))
+        mkdirSync(backup, { recursive: true })
+        for (const side of ["", "-wal", "-shm"]) if (exists(db + side)) copyFileSync(db + side, join(backup, `sessions.db${side}`))
+      }
+      const env = { ...process.env, HOME: w.home }
+      const run = Bun.spawnSync([bin.path, "session", "import", file], { cwd, env, stdout: "pipe", stderr: "pipe", timeout: 60_000 })
+      const printed = run.stdout.toString()
+      const id = printed.split("Session imported:")[1]?.trim().match(/^(\S+) - /)?.[1]
+      if (run.exitCode !== 0 || !id) throw new Error(`goose session import failed (exit ${run.exitCode}): ${(run.stderr.toString() || printed).trim().slice(0, 500)}`)
+
+      // Read it back as the reader reads Goose; a session that does not round-trip is removed again.
+      const back = await gooseReader.read({ tool: TOOL, sourceId: id, path: db }, w.home)
+      const n = countTurns(back)
+      const pairs = unpaired(back)
+      if (n.user !== plan.expect.users || n.assistant !== plan.expect.assistants || n.tool_call !== plan.expect.calls || pairs.calls.length || pairs.results.length) {
+        Bun.spawnSync([bin.path, "session", "remove", "--session-id", id], { cwd, env, stdout: "pipe", stderr: "pipe", timeout: 60_000 })
+        throw new Error(
+          `the imported Goose session did not read back as written (users ${n.user}/${plan.expect.users}, replies ${n.assistant}/${plan.expect.assistants}, tool calls ${n.tool_call}/${plan.expect.calls}, unpaired ${pairs.calls.length + pairs.results.length}); it was removed`,
+        )
+      }
+      return {
+        tool: TOOL,
+        way: "import",
+        sessionId: id,
+        written: [file, db],
+        open: `cd ${shellQuote(cwd)} && ${shellQuote(bin.command)} session --resume --session-id ${id} --history`,
+        lost: plan.lost,
+        dryRun: false,
+      }
+    },
+  }
+}
+
+export const gooseImportWriter = gooseWriter()

package/src/adapters/grok-cli/image.ts

@@ -0,0 +1,44 @@
+// Grok checks every image in chat_history.jsonl when it loads a session (crates/.../session/image_normalize.rs) and moves
+// the WHOLE file aside as chat_history.jsonl.corrupt when one fails, so a writer must not hand it an image it would reject.
+// Measured against Grok 0.2.103 with the real binary: each side must be at least 8 px and the area at least 512 px
+// (22x23 is rejected, 23x23 and 8x64 are accepted); 10000x10000 is accepted (its ceiling is above anything under our 5 MB limit).
+
+export const MIN_SIDE = 8
+export const MIN_AREA = 512
+
+/** Width and height read from the file header of a PNG, JPEG, GIF or WebP; undefined when it cannot be read. */
+export function imageSize(b: Buffer): { width: number; height: number } | undefined {
+  if (b.length > 24 && b.readUInt32BE(0) === 0x89504e47 && b.toString("latin1", 12, 16) === "IHDR") return { width: b.readUInt32BE(16), height: b.readUInt32BE(20) }
+  if (b.length > 10 && (b.toString("latin1", 0, 6) === "GIF87a" || b.toString("latin1", 0, 6) === "GIF89a")) return { width: b.readUInt16LE(6), height: b.readUInt16LE(8) }
+  if (b.length > 30 && b.toString("latin1", 0, 4) === "RIFF" && b.toString("latin1", 8, 12) === "WEBP") {
+    const kind = b.toString("latin1", 12, 16)
+    if (kind === "VP8X") return { width: 1 + b.readUIntLE(24, 3), height: 1 + b.readUIntLE(27, 3) }
+    if (kind === "VP8L" && b[20] === 0x2f) {
+      const bits = b.readUInt32LE(21)
+      return { width: 1 + (bits & 0x3fff), height: 1 + ((bits >> 14) & 0x3fff) }
+    }
+    if (kind === "VP8 ") return { width: b.readUInt16LE(26) & 0x3fff, height: b.readUInt16LE(28) & 0x3fff }
+    return undefined
+  }
+  if (b.length > 4 && b[0] === 0xff && b[1] === 0xd8) {
+    let i = 2
+    while (i + 9 < b.length) {
+      if (b[i] !== 0xff) return undefined
+      const m = b[i + 1]!
+      if (m === 0xff) { i++; continue }
+      if (m === 0xd8 || (m >= 0xd0 && m <= 0xd7) || m === 0x01) { i += 2; continue }
+      const len = b.readUInt16BE(i + 2)
+      if (m >= 0xc0 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) return { width: b.readUInt16BE(i + 7), height: b.readUInt16BE(i + 5) }
+      i += 2 + len
+    }
+  }
+  return undefined
+}
+
+/** Why Grok would reject this image on load, or undefined when it takes it. */
+export function grokRejects(b: Buffer): string | undefined {
+  const s = imageSize(b)
+  if (!s) return "unreadable image header"
+  if (s.width < MIN_SIDE || s.height < MIN_SIDE || s.width * s.height < MIN_AREA) return `too small (${s.width}x${s.height}; Grok needs sides of at least ${MIN_SIDE} px and ${MIN_AREA} px in all)`
+  return undefined
+}

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

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { grokReader } from "./reader.ts"
+import { grokNativeWriter } from "./writer.ts"
+
+// xAI Grok CLI (grok, "Grok Build"): reads its session folders and continues any session as a new
+// native Grok session that `grok --resume` opens.
+export const readers: Reader[] = [grokReader]
+export const writers: Writer[] = [grokNativeWriter]