@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/vscode-copilot/shared.ts

@@ -0,0 +1,68 @@
+import { copyFileSync, mkdirSync } from "node:fs"
+import { join } from "node:path"
+import { exists } from "../../fsutil.ts"
+import type { ToolKind } from "../../session/types.ts"
+
+// Helpers the VS Code chat family's writers share (Copilot Chat, Continue, PearAI, Void): picking the
+// arguments a tool call names in another tool's vocabulary, shell quoting, and the backup taken before
+// a writer changes a database another program owns.
+
+type Json = Record<string, unknown>
+
+const isObj = (v: unknown): v is Json => typeof v === "object" && v !== null && !Array.isArray(v)
+
+/** The first non-empty string among `keys` in a tool call's input (arrays of strings are joined with spaces). */
+export function pick(input: unknown, keys: string[]): string | undefined {
+  if (!isObj(input)) return undefined
+  for (const k of keys) {
+    const v = input[k]
+    if (typeof v === "string" && v) return v
+    if (Array.isArray(v) && v.length && v.every((x) => typeof x === "string")) return v.join(" ")
+  }
+  return undefined
+}
+
+/** Argument names other tools use for the same thing. */
+export const ARG = {
+  path: ["file_path", "filePath", "filepath", "path", "absolute_path", "target_file", "file", "uri"],
+  dir: ["dir_path", "dirPath", "path", "directory", "target_directory", "relative_workspace_path", "dir"],
+  content: ["content", "contents", "file_text", "text", "code"],
+  old: ["old_string", "oldString", "old_str", "old_text"],
+  new: ["new_string", "newString", "new_str", "new_text"],
+  command: ["command", "cmd", "commandLine"],
+  query: ["query", "pattern", "regex", "search", "q"],
+  url: ["url", "uri", "href"],
+}
+
+/** A tool call in the target's own terms, when its kind has an equivalent there; undefined keeps it as it was. */
+export type ToolMap = Partial<Record<ToolKind, (input: unknown) => { name: string; args: Json } | undefined>>
+
+export function mapTool(map: ToolMap, kind: ToolKind, input: unknown): { name: string; args: Json } | undefined {
+  return map[kind]?.(input)
+}
+
+/** Tool names every provider accepts: letters, digits, _ and -, at most 64. */
+export const safeToolName = (name: string) => name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "tool"
+
+/** A tool's input as an object, as the targets' tool-call records require. */
+export const asArgs = (input: unknown): Json => (isObj(input) ? input : input === undefined || input === null ? {} : { input })
+
+export const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+/**
+ * Copies a database another program owns (with its -wal and -shm files) to ~/.brain/backups/<tool>/<stamp>/
+ * before a writer changes it. Returns the folder; nothing is copied for files that do not exist yet.
+ */
+export function backup(home: string, tool: string, files: string[], now = new Date()): string {
+  const dir = join(home, ".brain", "backups", tool, now.toISOString().replace(/[:.]/g, "-"))
+  for (const f of files) {
+    for (const side of ["", "-wal", "-shm"]) {
+      if (!exists(f + side)) continue
+      // Files from different folders can share a name (two state.vscdb); keep their folder's name too.
+      const name = `${f.split("/").slice(-2).join("__")}${side}`
+      mkdirSync(dir, { recursive: true })
+      copyFileSync(f + side, join(dir, name))
+    }
+  }
+  return dir
+}

package/src/adapters/vscode-copilot/writer.ts

@@ -0,0 +1,546 @@
+import { Database } from "bun:sqlite"
+import { createHash, randomUUID } from "node:crypto"
+import { mkdirSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { appSupport, exists, isDir, isRunning, readJson } from "../../fsutil.ts"
+import { imageDataUrl, parseDataUrl } from "../../session/attachments.ts"
+import type { Attachment, 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 { reader } from "./reader.ts"
+import { LABEL, TESTED_VERSION, TOOL } from "./records.ts"
+import { ARG, type ToolMap, asArgs, backup, mapTool, pick, safeToolName, shellQuote } from "./shared.ts"
+
+// Continues a portable session in Copilot Chat in VS Code as a new local chat: the session is written the
+// way VS Code 1.144 stores its own (chatSessionStore.ts and chatSessionOperationLog.ts at the 1.144 commit
+// 2c33b50b), and an entry is added to the chat index so the Chat view's history lists it:
+//
+// - User/workspaceStorage/<workspace id>/chatSessions/<uuid>.jsonl: a mutation log holding one Initial
+//   entry, {kind: 0, v: ISerializableChatData v3}, which is what VS Code writes for a new session.
+// - The same folder's state.vscdb, ItemTable key 'chat.ChatSessionStore.index': {version: 1, entries}.
+//   VS Code lists history from this index, not from the folder, and throws the whole index away if any
+//   entry is malformed, so the entry is built as getSessionMetadata builds it and merged, never replaced.
+//
+// Each request carries two records of its reply, as Copilot's agent does. The response parts are what
+// the chat shows (markdown, tool invocations, thinking). result.metadata.toolCallRounds and
+// toolCallResults are what Copilot Chat 0.72 replays to the model on the next request
+// (AgentConversationHistory, ChatToolCalls): each round is one model call with its text and tool calls,
+// and each result is a LanguageModelToolResult marshalled with $mid 20/21. The request's agent is
+// github.copilot.editsAgent: Copilot keeps result metadata in history only for its own participants.
+//
+// The note saying where the session came from goes in the first request's renderedUserMessage, which
+// Copilot sends to the model in place of the request text while the chat shows only the person's words.
+// A compaction becomes a system-initiated request whose single round carries the summary
+// (metadata.summaries), which Copilot renders as <conversation-summary> in place of everything before it.
+//
+// state.vscdb is a database VS Code keeps open and rewrites from memory, so this writer runs only with
+// VS Code closed and backs the file up first.
+
+export const TESTED_VSCODE = ["1.144"]
+export const TESTED_COPILOT = ["0.72"]
+
+const APP = "Visual Studio Code.app"
+const INDEX_KEY = "chat.ChatSessionStore.index"
+const AGENT_ID = "github.copilot.editsAgent"
+
+/** The installed VS Code and its built-in Copilot Chat, read from the app bundle. */
+export function installedVSCode(home: string): { vscode?: string; copilot?: string } {
+  for (const root of ["/Applications", join(home, "Applications")]) {
+    const app = join(root, APP, "Contents", "Resources", "app")
+    const v = readJson<{ version?: string }>(join(app, "package.json"))?.version
+    if (!v) continue
+    const c = readJson<{ version?: string }>(join(app, "extensions", "copilot", "package.json"))?.version
+    return { vscode: v, ...(c ? { copilot: c } : {}) }
+  }
+  return {}
+}
+
+const line = (v: string | undefined) => v?.split(".").slice(0, 2).join(".")
+
+/**
+ * VS Code's id for a single-folder workspace (workspaces.ts getSingleFolderWorkspaceIdentifier): the md5 of
+ * the folder path and, on macOS, its birth time in milliseconds. Node rounds the birth time to whole
+ * milliseconds where Bun truncates, so it is rounded here as VS Code (on Node) sees it.
+ */
+export function workspaceId(folder: string): string {
+  const birth = Math.round(statSync(folder).birthtimeMs)
+  return createHash("md5").update(folder).update(String(birth)).digest("hex")
+}
+
+/** A file:// URI as VS Code's URI.toString() writes it: everything but unreserved characters and / is escaped. */
+export function fileUri(path: string): string {
+  let out = ""
+  for (const ch of path) out += /^[A-Za-z0-9\-._~/]$/.test(ch) ? ch : encodeURIComponent(ch)
+  return `file://${out}`
+}
+
+/** VS Code's user folder under a home. */
+export const userDir = (home: string) => join(appSupport(home), "Code", "User")
+
+/** The agent descriptor VS Code serializes with each request (IChatAgentData of Copilot's agent mode). */
+function agentData(extensionVersion: string) {
+  return {
+    extensionId: { value: "GitHub.copilot-chat", _lower: "github.copilot-chat" },
+    extensionVersion,
+    publisherDisplayName: "GitHub",
+    extensionPublisherId: "GitHub",
+    extensionDisplayName: "GitHub Copilot Chat",
+    id: AGENT_ID,
+    description: "Edit files in your workspace in agent mode",
+    when: "config.chat.agent.enabled",
+    metadata: { themeIcon: { id: "tools" }, hasFollowups: false, supportIssueReporting: false },
+    name: "agent",
+    fullName: "GitHub Copilot",
+    isDefault: true,
+    locations: ["panel"],
+    modes: ["agent"],
+    slashCommands: [],
+    disambiguation: [],
+  }
+}
+
+// Copilot's own names for what the call does (as its model sees them in 0.72), where the arguments map
+// cleanly; anything else keeps its name.
+const TOOLS: ToolMap = {
+  read: (i) => {
+    const filePath = pick(i, ARG.path)
+    return filePath ? { name: "read_file", args: { filePath } } : undefined
+  },
+  write: (i) => {
+    const filePath = pick(i, ARG.path)
+    const content = pick(i, ARG.content)
+    return filePath && content !== undefined ? { name: "create_file", args: { filePath, content } } : undefined
+  },
+  edit: (i) => {
+    const filePath = pick(i, ARG.path)
+    const oldString = pick(i, ARG.old)
+    const newString = pick(i, ARG.new)
+    return filePath && oldString !== undefined && newString !== undefined ? { name: "replace_string_in_file", args: { filePath, oldString, newString } } : undefined
+  },
+  shell: (i) => {
+    const command = pick(i, ARG.command)
+    return command ? { name: "run_in_terminal", args: { command, explanation: "", isBackground: false } } : undefined
+  },
+  list: (i) => {
+    const path = pick(i, ARG.dir)
+    return path ? { name: "list_dir", args: { path } } : undefined
+  },
+  search: (i) => {
+    const query = pick(i, ARG.query)
+    return query ? { name: "grep_search", args: { query, isRegexp: false } } : undefined
+  },
+}
+
+const markdown = (value: string) => ({ value, supportThemeIcons: false, supportHtml: false })
+
+/** A parsed request message with one text part, as ChatRequestTextPart serializes. */
+function message(text: string) {
+  const lines = text.split("\n")
+  return {
+    text,
+    parts: [
+      {
+        range: { start: 0, endExclusive: text.length },
+        editorRange: { startLineNumber: 1, startColumn: 1, endLineNumber: lines.length, endColumn: lines[lines.length - 1]!.length + 1 },
+        text,
+        kind: "text",
+      },
+    ],
+  }
+}
+
+type Call = Extract<Turn, { kind: "tool_call" }>
+type Result = Extract<Turn, { kind: "tool_result" }>
+
+interface Round {
+  id: string
+  response: string
+  calls: Array<{ id: string; name: string; arguments: string; source: Call }>
+  /** Reasoning shown before this round in the chat. */
+  thinking: string[]
+  /** A result for one of this round's calls has come back: the model call is over. */
+  closed: boolean
+  summary?: string
+}
+
+interface Req {
+  at?: number
+  text: string
+  /** A request the chat shows as a system notification: the continued-from note or a compaction. */
+  system?: string
+  /** This request's text is the continued-from note itself. */
+  isNote?: boolean
+  rounds: Round[]
+  /** Pasted images, as the chat's attachment entries (variableData.variables). */
+  images?: Record<string, unknown>[]
+  model?: string
+  usage?: { input?: number; output?: number }
+}
+
+export interface ChatPlan {
+  /** The ISerializableChatData written as the log's Initial entry. */
+  data: Record<string, unknown>
+  /** The session's entry in chat.ChatSessionStore.index. */
+  entry: Record<string, unknown>
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; calls: number }
+}
+
+/**
+ * A pasted image as VS Code 1.144 stores it in a request's variableData.variables: the chat attachment entry
+ * {kind:"image", id, name, value, mimeType, isPasted, references} with the bytes as {$base64} (mw.toExport turns a Uint8Array
+ * value into that and mw.fromExport back; Copilot Chat then builds a ChatReferenceBinaryData from value and mimeType, and
+ * ignores an entry with no value). Undefined when the image is gone, too large or not a format Copilot takes.
+ */
+export function imageVariable(a: Attachment): Record<string, unknown> | undefined {
+  const url = imageDataUrl(a)
+  const img = url ? parseDataUrl(url) : undefined
+  if (!img) return undefined
+  return {
+    kind: "image",
+    id: createHash("sha256").update(Buffer.from(img.base64, "base64")).digest("hex"),
+    name: a.name ?? "Pasted Image",
+    icon: { id: "file-media" },
+    value: { $base64: img.base64 },
+    mimeType: img.mime,
+    isPasted: true,
+    references: [],
+  }
+}
+
+/** The chat VS Code would store for `session` continued as local chat `sessionId`. Pure. */
+export function planChat(session: Session, opts: { sessionId: string; now: Date; extensionVersion: string }): ChatPlan {
+  const label = toolLabel(session.header.tool)
+  const drops = new Map<string, number>()
+  const drop = (what: string, n = 1) => drops.set(what, (drops.get(what) ?? 0) + n)
+  const results = new Map<string, Result>()
+  const callIds = new Set<string>()
+  for (const t of session.turns) {
+    if (t.kind === "tool_result" && !results.has(t.callId)) results.set(t.callId, t)
+    if (t.kind === "tool_call") callIds.add(t.id)
+  }
+  const note = continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10))
+
+  const reqs: Req[] = []
+  let req: Req | undefined
+  let round: Round | undefined
+  let pendingThinking: string[] = []
+  let model = session.header.models.at(-1)
+  const seen = new Set<string>()
+  const roundId = () => randomUUID()
+  // Call ids: kept when every provider accepts them, else replaced, the same way for the call and its result.
+  const ids = new Map<string, string>()
+  const callId = (id: string) => {
+    let v = ids.get(id)
+    if (!v) {
+      v = /^[A-Za-z0-9_-]{1,64}$/.test(id) && ![...ids.values()].includes(id) ? id : `call_${randomUUID().replace(/-/g, "").slice(0, 24)}`
+      ids.set(id, v)
+    }
+    return v
+  }
+  const at = (s?: string) => {
+    const t = s ? Date.parse(s) : Number.NaN
+    return Number.isFinite(t) ? t : undefined
+  }
+
+  const openRequest = (text: string, when?: string, system?: string, isNote = false) => {
+    req = { text, rounds: [], ...(system ? { system } : {}), ...(isNote ? { isNote } : {}), ...(at(when) ? { at: at(when) } : {}) }
+    reqs.push(req)
+    round = undefined
+    return req
+  }
+  const currentRound = (when?: string): Round => {
+    // Assistant output before any request opens one that carries the note in place of a person's words.
+    if (!req) openRequest(note, when, `Continued from ${label}`, true)
+    if (!round || round.closed) {
+      round = { id: roundId(), response: "", calls: [], thinking: pendingThinking, closed: false }
+      pendingThinking = []
+      req!.rounds.push(round)
+    }
+    return round
+  }
+
+  for (const t of session.turns) {
+    switch (t.kind) {
+      case "user": {
+        let text = t.text
+        const images: Record<string, unknown>[] = []
+        for (const a of t.attachments ?? []) {
+          if (a.kind === "file" && a.path) text += `\n\n[Attached file: ${a.path}]`
+          else {
+            const v = imageVariable(a)
+            if (v) images.push(v)
+            else drop("attachments")
+          }
+        }
+        if (!text.trim()) {
+          if (images.length) drop("attachments without text", images.length)
+          break
+        }
+        if (pendingThinking.length) drop("reasoning with no reply after it", pendingThinking.length)
+        pendingThinking = []
+        openRequest(text, t.at).images = images
+        break
+      }
+      case "assistant": {
+        if (!t.text.trim()) break
+        if (t.model) model = t.model
+        // Text after a tool call is the next model call.
+        if (round?.calls.length) round.closed = true
+        const r = currentRound(t.at)
+        r.response = r.response ? `${r.response}\n\n${t.text}` : t.text
+        req!.model = model
+        if (t.usage) req!.usage = { input: (req!.usage?.input ?? 0) + (t.usage.input ?? 0), output: (req!.usage?.output ?? 0) + (t.usage.output ?? 0) }
+        if (!req!.at && at(t.at)) req!.at = at(t.at)
+        break
+      }
+      case "tool_call": {
+        if (seen.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        seen.add(t.id)
+        const r = currentRound(t.at)
+        const mapped = mapTool(TOOLS, t.toolKind, t.input)
+        r.calls.push({ id: callId(t.id), name: mapped?.name ?? safeToolName(t.name), arguments: JSON.stringify(mapped?.args ?? asArgs(t.input)), source: t })
+        if (model) req!.model = model
+        break
+      }
+      case "tool_result":
+        if (!callIds.has(t.callId)) drop("tool results without a call")
+        else if (round?.calls.some((c) => c.source.id === t.callId)) round.closed = true
+        break
+      case "reasoning":
+        // Readable reasoning is shown as the chat's thinking part; Copilot replays only its provider's own.
+        if (t.text.trim()) {
+          pendingThinking.push(t.text)
+          drop("reasoning (shown in the chat, not sent back to the model)")
+        }
+        break
+      case "compaction": {
+        const r = openRequest(`Summary of the earlier conversation in ${label}`, t.at, `Earlier conversation in ${label}, summarized`)
+        round = { id: roundId(), response: "", calls: [], thinking: [], closed: true, summary: t.summary }
+        r.rounds.push(round)
+        break
+      }
+      case "file_edit":
+        if (!t.callId || !callIds.has(t.callId)) drop("file edits outside a tool call")
+        break
+      case "subagent":
+        drop("subagent sessions (their call and result are kept)")
+        break
+    }
+  }
+  if (pendingThinking.length) drop("reasoning with no reply after it", pendingThinking.length)
+  if (!reqs.length) throw new Error("nothing to continue: the session has no messages")
+
+  // Requests, with timestamps that never go backwards.
+  let clock = (reqs.find((r) => r.at)?.at ?? opts.now.getTime()) - 1
+  const tick = (t?: number) => (clock = t && t > clock ? t : clock + 1)
+  const agent = agentData(opts.extensionVersion)
+  const copilotSession = randomUUID()
+  let users = 0
+  let calls = 0
+  let noteGiven = reqs.some((r) => r.isNote)
+  const requests = reqs.map((r) => {
+    const timestamp = tick(r.at)
+    const toolCallResults: Record<string, unknown> = {}
+    const response: unknown[] = []
+    for (const round of r.rounds) {
+      for (const text of round.thinking) response.push({ kind: "thinking", value: text })
+      if (round.response) response.push(markdown(round.response))
+      for (const c of round.calls) {
+        const res = results.get(c.source.id)
+        if (!res) drop("tool calls without a result (closed as errors)")
+        const ok = res?.ok ?? false
+        let output = res?.output ?? "No result was recorded for this call; the session moved before it finished."
+        if (res?.fullPath) output += `\n\n[Full output: ${res.fullPath}]`
+        // Copilot's tools report failure in the text, and so does the reader.
+        if (!ok && !/^\s*error\b/i.test(output)) output = `Error: ${output}`
+        toolCallResults[c.id] = { $mid: 20, content: [{ $mid: 21, value: output }] }
+        response.push({
+          kind: "toolInvocationSerialized",
+          invocationMessage: `Ran \`${c.name}\``,
+          pastTenseMessage: `Ran \`${c.name}\``,
+          resultDetails: { input: c.arguments, output: [{ type: "embed", isText: true, value: output }], ...(ok ? {} : { isError: true }) },
+          isConfirmed: { type: 1 },
+          isComplete: true,
+          toolCallId: c.id,
+          toolId: c.name,
+        })
+        calls++
+      }
+    }
+    const rounds = r.rounds.map((x) => ({ id: x.id, response: x.response, toolCalls: x.calls.map((c) => ({ id: c.id, name: c.name, arguments: c.arguments })), toolInputRetry: 0 }))
+    const summaries = r.rounds.filter((x) => x.summary).map((x) => ({ toolCallRoundId: x.id, text: x.summary! }))
+    if (summaries.length) response.unshift(markdown(summaries.at(-1)!.text))
+    const answered = rounds.length > 0
+    const completedAt = tick()
+    const metadata: Record<string, unknown> = {
+      ...(answered ? { toolCallRounds: rounds, toolCallResults } : {}),
+      ...(summaries.length ? { summaries } : {}),
+      modelMessageId: randomUUID(),
+      responseId: randomUUID(),
+      sessionId: copilotSession,
+      agentId: AGENT_ID,
+      codeBlocks: [],
+    }
+    if (!r.system) {
+      users++
+      if (!noteGiven) {
+        // Sent to the model in place of the request text; the chat shows only the person's words.
+        metadata.renderedUserMessage = [{ type: 1, text: `${note}\n\n${r.text}` }]
+        noteGiven = true
+      }
+    }
+    return {
+      requestId: `request_${randomUUID()}`,
+      timestamp,
+      message: message(r.text),
+      variableData: { variables: r.images ?? [] },
+      response,
+      responseId: `response_${randomUUID()}`,
+      // A request the session moved on from before any reply is kept as a cancelled one, as VS Code keeps them.
+      result: answered
+        ? { timings: { firstProgress: 0, totalElapsed: completedAt - timestamp }, metadata, ...(r.model ? { details: r.model } : {}) }
+        : { errorDetails: { message: "Cancelled" }, metadata },
+      followups: [],
+      modelState: { value: answered ? 1 : 2, completedAt },
+      agent,
+      contentReferences: [],
+      codeCitations: [],
+      timeSpentWaiting: timestamp,
+      ...(r.usage?.input !== undefined ? { promptTokens: r.usage.input } : {}),
+      ...(r.usage?.output !== undefined ? { completionTokens: r.usage.output } : {}),
+      ...(r.system ? { isSystemInitiated: true, systemInitiatedLabel: r.system } : {}),
+    }
+  })
+
+  const title = `${(session.header.title ?? firstUserText(session) ?? "Session").replace(/\s+/g, " ").trim().slice(0, 80)} (from ${label})`
+  const created = requests[0]!.timestamp
+  const last = requests.at(-1)!
+  const data = {
+    version: TESTED_VERSION,
+    creationDate: created,
+    customTitle: title,
+    initialLocation: "panel",
+    // Restores in agent mode, so the next request goes to the agent whose history this is.
+    inputState: { attachments: [], mode: { id: "agent", kind: "agent" }, inputText: "", selections: [], contrib: {} },
+    responderUsername: "GitHub Copilot",
+    sessionId: opts.sessionId,
+    requests,
+    hasPendingEdits: false,
+    pendingRequests: [],
+  }
+  const entry = {
+    sessionId: opts.sessionId,
+    title,
+    lastMessageDate: last.timestamp,
+    timing: { created, lastRequestStarted: last.timestamp, lastRequestEnded: last.modelState.completedAt },
+    initialLocation: "panel",
+    hasPendingEdits: false,
+    isEmpty: false,
+    isExternal: false,
+    lastResponseState: last.modelState.value,
+  }
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  const remapped = [...ids].filter(([a, b]) => a !== b).length
+  if (remapped) lost.push(`tool call ids, replaced with ids every provider accepts (${remapped})`)
+  return { data, entry, lost, expect: { users, calls } }
+}
+
+const value = (db: Database, key: string): string | undefined => {
+  const row = db.query("SELECT value FROM ItemTable WHERE key = ?").get(key) as { value: string | Uint8Array } | null
+  return row ? (typeof row.value === "string" ? row.value : new TextDecoder().decode(row.value)) : undefined
+}
+
+/** The chat index in a workspace's state.vscdb, or a new one. */
+function readIndex(db: Database): { version: 1; entries: Record<string, unknown> } {
+  const text = value(db, INDEX_KEY)
+  if (text === undefined) {
+    // With no index, VS Code moves a workspace's chats out of its older key on its next start; an index
+    // written first would stop that, so the person opens the folder once and VS Code moves them itself.
+    if (value(db, "interactive.sessions") !== undefined) throw new Error("this workspace still has chats in VS Code's older store; open the folder in VS Code once (so it moves them), quit it, and try again")
+    return { version: 1, entries: {} }
+  }
+  const index = JSON.parse(text)
+  if (index?.version !== 1 || typeof index.entries !== "object" || index.entries === null) throw new Error(`the chat index in ${db.filename} has a format this writer does not know (version ${String(index?.version)})`)
+  return index
+}
+
+/** The Copilot Chat writer; `versions` and `running` are for tests, which must not depend on the installed app. */
+export function vscodeCopilotWriter(opts: { versions?: { vscode?: string; copilot?: string }; running?: () => boolean } = {}): Writer {
+  const installed = (home: string) => opts.versions ?? installedVSCode(home)
+  const running = opts.running ?? (() => isRunning("Code"))
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const { vscode, copilot } = installed(w.home)
+      if (!vscode) return { ok: false, why: "VS Code is not installed (no Visual Studio Code.app in /Applications or ~/Applications)" }
+      if (!TESTED_VSCODE.includes(line(vscode)!)) return { ok: false, why: `VS Code ${vscode} is not a version this writer was checked against (${TESTED_VSCODE.join(", ")})` }
+      if (!copilot || !TESTED_COPILOT.includes(line(copilot)!)) return { ok: false, why: `Copilot Chat ${copilot ?? "(not found)"} is not a version this writer was checked against (${TESTED_COPILOT.join(", ")})` }
+      if (running()) return { ok: false, why: "VS Code is running; quit it first (it keeps the chat index in a database it rewrites from memory)" }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; VS Code keeps chats per workspace folder` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      if (!w.dryRun && running()) throw new Error("VS Code is running; quit it first")
+      const { copilot } = installed(w.home)
+      const sessionId = randomUUID()
+      const storage = join(userDir(w.home), "workspaceStorage", workspaceId(w.cwd))
+      const file = join(storage, "chatSessions", `${sessionId}.jsonl`)
+      const db = join(storage, "state.vscdb")
+      const plan = planChat(session, { sessionId, now: new Date(), extensionVersion: copilot ?? `${TESTED_COPILOT[0]}.0` })
+      const written = [file, db, ...(exists(join(storage, "workspace.json")) ? [] : [join(storage, "workspace.json")])]
+      let backedUp: string | undefined
+      if (!w.dryRun) {
+        mkdirSync(join(storage, "chatSessions"), { recursive: true })
+        // VS Code writes this beside a workspace's storage the first time it opens the folder.
+        if (!exists(join(storage, "workspace.json"))) writeFileSync(join(storage, "workspace.json"), JSON.stringify({ folder: fileUri(w.cwd) }, undefined, 2))
+        writeFileSync(file, `${JSON.stringify({ kind: 0, v: plan.data })}\n`, { flag: "wx" })
+        try {
+          const back = await reader.read({ tool: TOOL, sourceId: sessionId, path: file }, w.home)
+          const n = countTurns(back)
+          const pairs = unpaired(back)
+          if (n.user !== plan.expect.users || n.tool_call !== plan.expect.calls || pairs.calls.length || pairs.results.length)
+            throw new Error(`the new chat did not read back intact (${n.user} of ${plan.expect.users} requests, ${n.tool_call} of ${plan.expect.calls} tool calls, ${pairs.calls.length + pairs.results.length} unpaired)`)
+          if (exists(db)) backedUp = backup(w.home, TOOL, [db])
+          const conn = new Database(db, { create: true })
+          try {
+            // The schema VS Code creates (base/parts/storage/node/storage.ts); a no-op on an existing store.
+            conn.exec("CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB)")
+            conn.transaction(() => {
+              const index = readIndex(conn)
+              index.entries[sessionId] = plan.entry
+              conn.query("INSERT OR REPLACE INTO ItemTable (key, value) VALUES (?, ?)").run(INDEX_KEY, JSON.stringify(index))
+            })()
+          } finally {
+            conn.close()
+          }
+        } catch (e) {
+          rmSync(file, { force: true })
+          throw e
+        }
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId,
+        written,
+        open: `code ${shellQuote(w.cwd)}`,
+        note: `In the Chat view, open the chat history (Show Chats…) and pick "${plan.entry.title}".${backedUp ? ` The workspace's state.vscdb was backed up to ${backedUp}.` : ""}`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const vscodeCopilotNativeWriter = vscodeCopilotWriter()

package/src/adapters/zed/index.ts

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { zedReader } from "./reader.ts"
+import { zedNativeWriter } from "./writer.ts"
+
+// Zed's agent panel: reads native agent threads from threads.db, and continues any session as a new native
+// thread there (written only while Zed is closed, after a backup).
+export const readers: Reader[] = [zedReader]
+export const writers: Writer[] = [zedNativeWriter]