@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/zed/reader.ts

@@ -0,0 +1,198 @@
+import type { Database } from "bun:sqlite"
+import { exists, gitInfo } from "../../fsutil.ts"
+import type { Attachment, Session, Turn } from "../../session/types.ts"
+import { asText, clip, header, iso, lossCounter, noteModel } from "../../session/util.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { CONTINUED_NOTE, LABEL, THREAD_VERSION, TOOL, threadsDb, zedToolKind } from "./records.ts"
+
+// Zed's native agent threads (records.ts has the layout). Root threads are listed; a subagent thread
+// (parent_id set) belongs to its parent and is not listed on its own. Threads of external ACP agents
+// (Claude Code, Gemini CLI, ...) are not here: Zed keeps only their metadata and the agent keeps the content.
+
+type Json = Record<string, any>
+
+/** Columns a threads table has; older Zed versions lack parent_id, folder_paths and created_at. */
+const columns = (db: Database) => new Set((db.query("PRAGMA table_info(threads)").all() as Array<{ name: string }>).map((c) => c.name))
+
+/** The first of a thread's folders (folder_paths is newline-joined), the project it ran in. */
+const firstFolder = (paths: unknown) => (typeof paths === "string" && paths ? paths.split("\n")[0] : undefined)
+
+export const zedReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+  async list(home) {
+    const path = threadsDb(home)
+    if (!exists(path)) return []
+    const rows = withSnapshot(path, (db) => {
+      const have = columns(db)
+      if (!have.has("id")) return []
+      const pick = (c: string) => (have.has(c) ? c : `NULL AS ${c}`)
+      return db
+        .query(`SELECT id, ${pick("parent_id")}, ${pick("folder_paths")}, summary, updated_at, ${pick("created_at")} FROM threads ORDER BY updated_at DESC`)
+        .all() as Json[]
+    })
+    const refs: SessionRef[] = []
+    for (const r of rows) {
+      if (r.parent_id) continue
+      const cwd = firstFolder(r.folder_paths)
+      refs.push({
+        tool: TOOL,
+        sourceId: String(r.id),
+        path,
+        ...(r.summary ? { title: String(r.summary) } : {}),
+        ...(cwd ? { cwd } : {}),
+        ...(iso(r.updated_at) ? { updatedAt: iso(r.updated_at)! } : {}),
+      })
+    }
+    return refs
+  },
+  async read(ref, home) {
+    const path = exists(ref.path) ? ref.path : threadsDb(home)
+    const row = withSnapshot(path, (db) => {
+      const have = columns(db)
+      const pick = (c: string) => (have.has(c) ? c : `NULL AS ${c}`)
+      return db.query(`SELECT data_type, data, ${pick("folder_paths")}, summary, updated_at, ${pick("created_at")} FROM threads WHERE id = ?`).get(ref.sourceId) as Json | null
+    })
+    if (!row) throw new Error(`thread ${ref.sourceId} is not in ${path}`)
+    const bytes = row.data instanceof Uint8Array ? row.data : Buffer.from(String(row.data ?? ""))
+    let text: string
+    if (row.data_type === "zstd") text = Buffer.from(Bun.zstdDecompressSync(bytes)).toString("utf8")
+    else if (row.data_type === "json") text = Buffer.from(bytes).toString("utf8")
+    else throw new Error(`thread ${ref.sourceId} has an unknown data type: ${String(row.data_type)}`)
+    return parseThread(JSON.parse(text) as Json, {
+      id: ref.sourceId,
+      path,
+      cwd: firstFolder(row.folder_paths),
+      createdAt: iso(row.created_at),
+      updatedAt: iso(row.updated_at),
+      home,
+    })
+  },
+}
+
+/** A thread's tool input as the value it holds: {type, value} is how Zed writes it, anything else is raw JSON. */
+function toolInput(input: unknown): unknown {
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    const o = input as Json
+    if (Object.keys(o).length === 2 && (o.type === "json" || o.type === "text") && "value" in o) return o.value
+  }
+  return input
+}
+
+/** A tool result's text: its Text parts (strings, {Text}, {type: "text"} and {text} all occur), images counted. */
+function resultText(content: unknown, images: () => void): string {
+  const parts = Array.isArray(content) ? content : [content]
+  const out: string[] = []
+  for (const p of parts) {
+    if (typeof p === "string") out.push(p)
+    else if (p && typeof p === "object") {
+      const o = p as Json
+      const text = o.Text ?? o.text ?? (o.type === "text" ? o.text : undefined)
+      if (typeof text === "string") out.push(text)
+      else images()
+    }
+  }
+  return out.join("")
+}
+
+/** A mention's name, as Zed shows it on the chip (MentionUri::name, simplified). */
+function mentionName(uri: Json): { kind: string; name: string; path?: string } {
+  const [kind, v] = Object.entries(uri ?? {})[0] ?? ["Unknown", {}]
+  const o = (v ?? {}) as Json
+  const path = typeof o.abs_path === "string" ? o.abs_path : undefined
+  const name = typeof o.name === "string" ? o.name : path ?? (typeof o.url === "string" ? o.url : kind)
+  return { kind, name, ...(path ? { path } : {}) }
+}
+
+/** A DbThread (version 0.3.0) as a portable session. */
+export function parseThread(
+  thread: Json,
+  ctx: { id: string; path: string; cwd?: string; createdAt?: string; updatedAt?: string; home: string },
+): Session {
+  if (thread.version !== THREAD_VERSION)
+    throw new Error(`thread ${ctx.id} is in Zed's format ${String(thread.version ?? "agent 1")}, not ${THREAD_VERSION}; Zed upgrades it when the thread is next opened`)
+  const h = header(TOOL, ctx.id, {
+    sourcePath: ctx.path,
+    ...(thread.title ? { title: String(thread.title) } : {}),
+    project: ctx.cwd ? { cwd: ctx.cwd, ...gitInfo(ctx.cwd, ctx.home) } : {},
+    ...(ctx.createdAt ? { startedAt: ctx.createdAt } : {}),
+    ...((iso(thread.updated_at) ?? ctx.updatedAt) ? { updatedAt: iso(thread.updated_at) ?? ctx.updatedAt } : {}),
+  })
+  const model = thread.model && typeof thread.model === "object" ? `${thread.model.provider}/${thread.model.model}` : undefined
+  noteModel(h, model)
+  const lost = lossCounter()
+  const turns: Turn[] = []
+  // Zed stores no per-message times: every turn carries the thread's last update, the best it says.
+  const at = h.updatedAt
+
+  for (const m of Array.isArray(thread.messages) ? thread.messages : []) {
+    if (m === "Resume") continue // Zed's own "Continue where you left off", not the person's words
+    if (!m || typeof m !== "object") {
+      lost.add("unknown message kinds")
+      continue
+    }
+    if (m.User) {
+      const parts: string[] = []
+      const attachments: Attachment[] = []
+      for (const c of Array.isArray(m.User.content) ? m.User.content : []) {
+        if (typeof c?.Text === "string") parts.push(c.Text)
+        else if (c?.Mention) {
+          const content = typeof c.Mention.content === "string" ? c.Mention.content : ""
+          const continued = content.match(CONTINUED_NOTE)
+          if (continued?.[1] && !h.parent) {
+            h.parent = { id: continued[1], kind: "continued" }
+            continue
+          }
+          const { kind, name, path } = mentionName(c.Mention.uri)
+          if (path) attachments.push({ kind: "file", path, name })
+          parts.push(content ? `[@${name} (${kind})]\n${clip(content).text}` : `[@${name}]`)
+        } else if (c?.Image) lost.add("images")
+        else lost.add("unknown user content")
+      }
+      const text = parts.join("\n\n")
+      if (text.trim() || attachments.length) turns.push({ kind: "user", ...(at ? { at } : {}), text, ...(attachments.length ? { attachments } : {}) })
+      continue
+    }
+    if (m.Agent) {
+      const results = (m.Agent.tool_results ?? {}) as Json
+      for (const c of Array.isArray(m.Agent.content) ? m.Agent.content : []) {
+        if (typeof c?.Text === "string") {
+          if (c.Text.trim()) turns.push({ kind: "assistant", ...(at ? { at } : {}), text: c.Text, ...(model ? { model } : {}) })
+        } else if (c?.Thinking) {
+          if (typeof c.Thinking.text === "string" && c.Thinking.text.trim()) turns.push({ kind: "reasoning", ...(at ? { at } : {}), text: c.Thinking.text })
+          else if (c.Thinking.signature) lost.add("signed reasoning")
+        } else if (c?.RedactedThinking !== undefined) lost.add("redacted reasoning")
+        else if (c?.ToolUse) {
+          const u = c.ToolUse as Json
+          const name = String(u.name ?? "tool")
+          turns.push({ kind: "tool_call", ...(at ? { at } : {}), id: String(u.id), name, toolKind: zedToolKind(name), input: toolInput(u.input) })
+        } else lost.add("unknown agent content")
+      }
+      // Results sit beside the calls in the same message, keyed by tool use id, in the order they came back.
+      for (const r of Object.values(results) as Json[]) {
+        let images = 0
+        const out = clip(resultText(r.content, () => images++))
+        if (images) lost.add("images in tool results", images)
+        turns.push({
+          kind: "tool_result",
+          ...(at ? { at } : {}),
+          callId: String(r.tool_use_id),
+          ok: r.is_error !== true,
+          output: out.text || (r.output !== undefined && r.output !== null ? clip(asText(r.output)).text : ""),
+          ...(out.truncated ? { truncated: true } : {}),
+        })
+      }
+      if (m.Agent.reasoning_details) lost.add("provider reasoning details")
+      continue
+    }
+    if (m.Compaction) {
+      if (typeof m.Compaction.Summary === "string") turns.push({ kind: "compaction", ...(at ? { at } : {}), summary: m.Compaction.Summary })
+      else lost.add("provider-native compaction")
+      continue
+    }
+    lost.add("unknown message kinds")
+  }
+  lost.flush(h)
+  return { header: h, turns }
+}

package/src/adapters/zed/records.ts

@@ -0,0 +1,87 @@
+import { join } from "node:path"
+import { appSupport, exists, versionOf } from "../../fsutil.ts"
+import type { ToolKind } from "../../session/types.ts"
+import { toolKindOf } from "../../session/util.ts"
+
+// What Zed's native agent threads look like, as far as this adapter relies on it. Checked against Zed's
+// source at v1.26.2, v1.27.0 and main (2026-11-07): crates/agent/src/db.rs (ThreadsDatabase, DbThread),
+// crates/agent/src/thread.rs (Message and its content), crates/language_model_core (tool use and result),
+// crates/acp_thread/src/mention.rs (MentionUri) and crates/agent_ui/src/thread_metadata_store.rs (the sidebar).
+// Catalogue: docs/sessions/2026-11-08-session-formats.md, entries 49 and 70.
+//
+// One row per thread in <data dir>/threads/threads.db, table `threads`: id (an ACP session id, a v4 uuid
+// for native threads), parent_id (subagent threads), folder_paths and folder_paths_order (the project's
+// folders, newline- and comma-joined), summary (the title), updated_at and created_at (RFC 3339), data_type
+// ("zstd" or "json") and data: the DbThread as JSON with a `version` field, zstd level 3.
+
+export const TOOL = "zed"
+export const LABEL = "Zed"
+
+/** DbThread::VERSION. Any other version is Zed's legacy "agent 1" format, which Zed upgrades on load. */
+export const THREAD_VERSION = "0.3.0"
+
+/** Zed releases whose thread format was checked in their source; the writer was run against 1.27.0. */
+export const TESTED_VERSIONS = ["1.26.2", "1.27.0"]
+
+/** Zed's data dir: ~/Library/Application Support/Zed on macOS, ~/.local/share/zed elsewhere (paths::data_dir). */
+export const dataDir = (home: string) =>
+  process.platform === "darwin" ? join(appSupport(home), "Zed") : join(home, ".local", "share", "zed")
+
+export const threadsDb = (home: string) => join(dataDir(home), "threads", "threads.db")
+
+/** The statements Zed runs when it opens threads.db (ThreadsDatabase::new), so a new file matches its own. */
+export const SCHEMA = [
+  "CREATE TABLE IF NOT EXISTS threads (id TEXT PRIMARY KEY, summary TEXT NOT NULL, updated_at TEXT NOT NULL, data_type TEXT NOT NULL, data BLOB NOT NULL)",
+  "ALTER TABLE threads ADD COLUMN parent_id TEXT",
+  "ALTER TABLE threads ADD COLUMN folder_paths TEXT",
+  "ALTER TABLE threads ADD COLUMN folder_paths_order TEXT",
+  "ALTER TABLE threads ADD COLUMN created_at TEXT",
+  "CREATE INDEX IF NOT EXISTS threads_list_metadata ON threads (updated_at, created_at, id, parent_id, folder_paths, folder_paths_order, summary)",
+]
+
+/** Process names of a running Zed (the macOS app's binary is `zed`; Linux packages also ship `zeditor`). */
+export const PROCESSES = ["zed", "Zed", "zeditor", "zed-editor"]
+
+/** Zed's own tools (crates/agent/src/tools), where the name alone does not say what they do. */
+const KINDS: Record<string, ToolKind> = {
+  terminal: "shell",
+  read_file: "read",
+  edit_file: "edit",
+  streaming_edit_file: "edit",
+  grep: "search",
+  find_path: "search",
+  list_directory: "list",
+  fetch: "web",
+  web_search: "web",
+  spawn_agent: "task",
+  create_directory: "write",
+  copy_path: "write",
+  move_path: "write",
+  delete_path: "edit",
+}
+
+export const zedToolKind = (name: string): ToolKind => KINDS[name] ?? toolKindOf(name)
+
+const semver = (v: string | undefined) => v?.match(/(\d+\.\d+\.\d+)/)?.[1]
+
+/**
+ * The installed Zed's version: the app bundle's CFBundleShortVersionString on macOS (what `zed --version`
+ * prints too), else the `zed` CLI. Undefined when Zed is not installed.
+ */
+export function zedVersion(home: string): string | undefined {
+  if (process.platform === "darwin") {
+    for (const app of ["/Applications/Zed.app", join(home, "Applications", "Zed.app")]) {
+      const plist = join(app, "Contents", "Info.plist")
+      if (!exists(plist)) continue
+      const p = Bun.spawnSync(["plutil", "-extract", "CFBundleShortVersionString", "raw", "-o", "-", plist], { stdout: "pipe", stderr: "pipe" })
+      const v = p.exitCode === 0 ? semver(p.stdout.toString()) : undefined
+      if (v) return v
+    }
+  }
+  return semver(versionOf("zed")) ?? semver(versionOf("zeditor"))
+}
+
+/** The first message's note, recognised by the reader so it is not taken for the person's request. */
+export const continuedNote = (label: string, id: string, when: string) =>
+  `This thread continues ${label} session ${id}, carried over by brain session on ${when}. The messages that follow are its history; reasoning and anything listed as lost did not carry over. Check files before relying on details, since they may have changed.`
+export const CONTINUED_NOTE = /^This thread continues .+? session (\S+), carried over by brain session/

package/src/adapters/zed/writer.ts

@@ -0,0 +1,341 @@
+import { Database } from "bun:sqlite"
+import { copyFileSync, mkdirSync, readFileSync, realpathSync, statSync } from "node:fs"
+import { dirname, extname, join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir, isRunning } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { countTurns, firstUserText, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { zedReader } from "./reader.ts"
+import { LABEL, PROCESSES, SCHEMA, TESTED_VERSIONS, THREAD_VERSION, TOOL, continuedNote, threadsDb, zedVersion } from "./records.ts"
+
+// Continues a portable session in Zed as a new native agent thread: one row in threads.db, written the way
+// ThreadsDatabase::save_thread_sync writes it (a DbThread as JSON with its version, zstd level 3, the folder
+// list and RFC 3339 times), so Thread History lists it and opening it loads it. On its next launch Zed adds
+// the thread to the sidebar itself (migrate_thread_metadata in agent_ui's thread_metadata_store.rs), and keeps
+// it unarchived because it is the newest of its batch for its project; the sidebar's own database is not touched.
+//
+// Messages are regrouped Zed's way: one Agent message per model response, holding its text, readable
+// reasoning (Thinking without a signature, which Zed sends as text or leaves out per provider) and tool
+// uses, with each use's result in the same message's tool_results. Zed sends a tool use to the model only
+// when it has a result, so a call without one is closed as an error. Results keep `output` empty, so on
+// replay Zed shows their text instead of asking each tool to rebuild its own view. Compaction is Zed's own
+// Message::Compaction(Summary): Zed sends the model only what follows the last one.
+//
+// Zed has no hidden message. The note saying where the thread came from is a thread mention on the first
+// request: a chip in the panel, and an attached <threads> context block for the model, not the person's words.
+//
+// The database is written only while Zed is closed, after a copy of it is kept under ~/.brain/backups/zed/.
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+function realCwd(cwd: string): string {
+  try {
+    return realpathSync(cwd)
+  } catch {
+    return cwd
+  }
+}
+
+/** Tool names the providers Zed talks to accept. */
+const toolName = (name: string) => name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "tool"
+
+/** Tool use ids the same way: Anthropic's ^[a-zA-Z0-9_-]+$. */
+const useId = (id: string) => id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "tool_use"
+
+/** Tool input as an object, which every provider expects; a raw string (apply_patch) or array is wrapped. */
+const objectInput = (input: unknown): Record<string, unknown> =>
+  input && typeof input === "object" && !Array.isArray(input) ? (input as Record<string, unknown>) : { input: input ?? null }
+
+const PNG_LIMIT = 5 * 1024 * 1024
+
+type Json = Record<string, any>
+type Call = Extract<Turn, { kind: "tool_call" }>
+interface AgentMessage {
+  content: Json[]
+  tool_results: Record<string, Json>
+  reasoning_details: null
+}
+
+export interface ThreadPlan {
+  /** The DbThread JSON as Zed serialises it, with its version. */
+  thread: Json
+  title: string
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+}
+
+/** The DbThread for `session` as a new Zed thread. Pure apart from reading attached PNG images. */
+export function planThread(session: Session, opts: { now: Date }): ThreadPlan {
+  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 results = new Map<string, Extract<Turn, { kind: "tool_result" }>>()
+  for (const t of session.turns) if (t.kind === "tool_result" && !results.has(t.callId)) results.set(t.callId, t)
+
+  const messages: Json[] = []
+  const expect = { users: 0, assistants: 0, calls: 0 }
+  const note = {
+    Mention: {
+      uri: { Thread: { id: session.header.id, name: `${label} session ${session.header.sourceId}` } },
+      content: continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10)),
+    },
+  }
+  let noted = false
+
+  let cur: AgentMessage | undefined
+  const flush = () => {
+    if (cur?.content.length) messages.push({ Agent: cur })
+    cur = undefined
+  }
+  const agent = () => (cur ??= { content: [], tool_results: {}, reasoning_details: null })
+  const hasUse = () => !!cur?.content.some((c) => "ToolUse" in c)
+  // Which message holds each call, so a late result still lands beside its call; ids remapped once.
+  const owner = new Map<string, AgentMessage>()
+  const ids = new Map<string, string>()
+  const used = new Set<string>()
+  let remapped = 0
+  const idFor = (id: string) => {
+    let v = ids.get(id)
+    if (v) return v
+    v = useId(id)
+    for (let n = 2; used.has(v); n++) v = `${useId(id)}_${n}`
+    ids.set(id, v)
+    used.add(v)
+    if (v !== id) remapped++
+    return v
+  }
+  const result = (msg: AgentMessage, call: Call, ok: boolean, output: string) => {
+    msg.tool_results[idFor(call.id)] = {
+      tool_use_id: idFor(call.id),
+      tool_name: toolName(call.name),
+      is_error: !ok,
+      content: [{ Text: output.trim() ? output : "(no output)" }],
+      output: null,
+    }
+  }
+  const calls = new Map<string, Call>()
+
+  for (const t of session.turns) {
+    switch (t.kind) {
+      case "user": {
+        flush()
+        const content: Json[] = []
+        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
+          }
+          // Zed's LanguageModelImage holds a base64 PNG and nothing else.
+          let size = Number.POSITIVE_INFINITY
+          try {
+            size = statSync(a.path).size
+          } catch {}
+          if ((a.mime === "image/png" || extname(a.path).toLowerCase() === ".png") && size <= PNG_LIMIT)
+            content.push({ Image: { source: readFileSync(a.path).toString("base64") } })
+          else drop("images Zed cannot hold (it keeps PNG only)")
+        }
+        if (!text.trim() && !content.length) break
+        if (text.trim()) content.unshift({ Text: text })
+        if (!noted) {
+          content.unshift(note)
+          noted = true
+        }
+        messages.push({ User: { id: crypto.randomUUID(), content } })
+        if (text.trim()) expect.users++
+        break
+      }
+      case "assistant":
+        // Text after a tool use is a new response: it was written after the use's result came back.
+        if (hasUse()) flush()
+        if (!t.text.trim()) break
+        agent().content.push({ Text: t.text })
+        expect.assistants++
+        break
+      case "reasoning":
+        if (hasUse()) flush()
+        if (t.text.trim()) agent().content.push({ Thinking: { text: t.text, signature: null } })
+        break
+      case "tool_call": {
+        if (calls.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        const input = objectInput(t.input)
+        const name = toolName(t.name)
+        if (name !== t.name) drop("tool names changed to fit Zed")
+        const msg = agent()
+        msg.content.push({
+          ToolUse: { id: idFor(t.id), name, raw_input: JSON.stringify(input), input: { type: "json", value: input }, is_input_complete: true, thought_signature: null },
+        })
+        owner.set(t.id, msg)
+        calls.set(t.id, t)
+        expect.calls++
+        break
+      }
+      case "tool_result": {
+        const msg = owner.get(t.callId)
+        const call = calls.get(t.callId)
+        if (!msg || !call) {
+          drop("tool results without a call")
+          break
+        }
+        if (msg.tool_results[idFor(t.callId)]) {
+          drop("repeated tool results")
+          break
+        }
+        result(msg, call, t.ok, t.fullPath ? `${t.output}\n\n[Full output: ${t.fullPath}]` : t.output)
+        break
+      }
+      case "compaction":
+        flush()
+        messages.push({ Compaction: { Summary: `[Summary of the earlier conversation in ${label}, which replaced the turns before it]\n\n${t.summary}` } })
+        break
+      case "file_edit":
+        if (!t.callId || !calls.has(t.callId)) drop("file edits outside a tool call")
+        break
+      case "subagent":
+        drop("subagent sessions (their results stay in the parent's tool results)")
+        break
+    }
+  }
+  flush()
+  // Zed leaves a tool use without a result out of what it sends, so every call is answered.
+  for (const [id, call] of calls) {
+    const msg = owner.get(id)!
+    if (!msg.tool_results[idFor(id)]) {
+      result(msg, call, false, "No result was recorded for this call; the session moved on before it finished.")
+      drop("tool calls without a result (closed as errors)")
+    }
+  }
+  if (!messages.length) throw new Error("nothing Zed can show: the session has no messages or tool calls")
+  // A session that opens with the model (a summary, a reply) still says where it came from.
+  if (!noted) messages.unshift({ User: { id: crypto.randomUUID(), content: [note] } })
+
+  const firstText = firstUserText(session)?.replace(/\s+/g, " ").trim().slice(0, 60)
+  const title = `${session.header.title ?? firstText ?? "Session"} (from ${label})`
+  const thread: Json = {
+    title,
+    messages,
+    updated_at: opts.now.toISOString(),
+    detailed_summary: null,
+    initial_project_snapshot: null,
+    cumulative_token_usage: {},
+    request_token_usage: {},
+    // No model: a foreign model id would leave the thread's model unresolved; Zed picks the person's default.
+    model: null,
+    profile: null,
+    subagent_context: null,
+    speed: null,
+    thinking_enabled: false,
+    thinking_effort: null,
+    draft_prompt: null,
+    ui_scroll_position: null,
+    sandboxed_terminal_temp_dir: null,
+    sandbox_grants: { write_paths: [], network_hosts: [], network_any_host: false, allow_fs_write_all: false, unsandboxed: false, sandbox_fallback: false },
+    version: THREAD_VERSION,
+  }
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  if (remapped) lost.push(`tool call ids, changed to fit Zed (${remapped})`)
+  return { thread, title, lost, expect }
+}
+
+/** chrono's to_rfc3339 for a UTC time, which is how Zed fills the updated_at and created_at columns. */
+const rfc3339 = (d: Date) => d.toISOString().replace("Z", "+00:00")
+
+/** A filesystem-safe timestamp for a backup folder. */
+const stamp = (d: Date) => d.toISOString().replace(/[:.]/g, "-")
+
+/** Copies the database and its -wal and -shm files; returns the folder. */
+export function backupDb(home: string, path: string, now: Date): string {
+  const dir = join(home, ".brain", "backups", TOOL, stamp(now))
+  mkdirSync(dir, { recursive: true })
+  for (const side of ["", "-wal", "-shm", "-journal"]) if (exists(path + side)) copyFileSync(path + side, join(dir, `threads.db${side}`))
+  return dir
+}
+
+/** The Zed writer; `version` and `running` are for tests, which must not depend on what is installed or open. */
+export function zedWriter(opts: { version?: string; running?: () => boolean } = {}): Writer {
+  const installed = (home: string) => opts.version ?? zedVersion(home)
+  const running = opts.running ?? (() => PROCESSES.some(isRunning))
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed(w.home)
+      if (!v) return { ok: false, why: "Zed is not installed (no Zed.app and no `zed` on the PATH)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Zed ${v} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+      if (running()) return { ok: false, why: "Zed is running; quit it first, since it keeps threads.db open and caches its thread list" }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; Zed files the thread under the project it belongs to` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const now = new Date()
+      const cwd = realCwd(w.cwd)
+      const id = crypto.randomUUID()
+      const path = threadsDb(w.home)
+      const plan = planThread(session, { now })
+      const written = [path]
+      if (!w.dryRun) {
+        if (running()) throw new Error("Zed is running; quit it before writing its threads database")
+        if (exists(path)) written.push(backupDb(w.home, path, now))
+        else mkdirSync(dirname(path), { recursive: true })
+        const json = JSON.stringify(plan.thread)
+        const data = Bun.zstdCompressSync(Buffer.from(json), { level: 3 })
+        const db = new Database(path)
+        try {
+          db.exec("PRAGMA busy_timeout = 5000")
+          for (const sql of SCHEMA) {
+            try {
+              db.exec(sql)
+            } catch {} // the column is already there, as Zed itself tolerates
+          }
+          // A plain INSERT: a new thread never replaces a row, even in the impossible case of an id clash.
+          db.query(
+            "INSERT INTO threads (id, parent_id, folder_paths, folder_paths_order, summary, updated_at, data_type, data, created_at) VALUES (?, NULL, ?, ?, ?, ?, 'zstd', ?, ?)",
+          ).run(id, cwd, "0", plan.title, rfc3339(now), data, rfc3339(now))
+        } finally {
+          db.close()
+        }
+        // Read it back as Zed's own rows are read; a row that does not round-trip is removed.
+        let problem: string | undefined
+        try {
+          const back = await zedReader.read({ tool: TOOL, sourceId: id, path }, 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)
+            problem = `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}`
+        } catch (e) {
+          problem = e instanceof Error ? e.message : String(e)
+        }
+        if (problem) {
+          const db2 = new Database(path)
+          try {
+            db2.query("DELETE FROM threads WHERE id = ?").run(id)
+          } finally {
+            db2.close()
+          }
+          throw new Error(`the new Zed thread did not read back as written (${problem}); it was removed`)
+        }
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId: id,
+        written,
+        open: `zed ${shellQuote(cwd)}`,
+        note: `In the Agent Panel, open the thread "${plan.title}" from the sidebar or Thread History.`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const zedNativeWriter = zedWriter()