@100xprompt/brain 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,9 @@
+import type { Reader, Writer } from "../types.ts"
+import { reader } from "./reader.ts"
+import { vscodeCopilotNativeWriter } from "./writer.ts"
+
+// Copilot Chat in VS Code: reads every local chat (.json and the 1.109+ .jsonl log), and continues any
+// session as a new local chat in the Chat view's history (VS Code must be closed while it is written).
+export { reader }
+export const readers: Reader[] = [reader]
+export const writers: Writer[] = [vscodeCopilotNativeWriter]

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

@@ -0,0 +1,212 @@
+import { closeSync, openSync, readFileSync, readSync, statSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { appSupport, gitInfo, isDir, ls, mtime, readJson } from "../../fsutil.ts"
+import type { Turn } from "../../session/types.ts"
+import { header, iso, lossCounter } from "../../session/util.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { CONTINUED_NOTE } from "../claude-code/records.ts"
+import { type Ctx, firstMessage, LABEL, loadSession, requestTurns, TESTED_VERSION, TOOL, uriPath } from "./records.ts"
+
+// Copilot Chat in VS Code: chats live in the workbench's own storage, not the extension's. Per workspace,
+// User/workspaceStorage/<hash>/chatSessions/<sessionId>.json (before 1.109) or .jsonl (a mutation log,
+// 1.109 and later), with workspace.json mapping the hash to its folder; chats from windows with no folder
+// open are in User/globalStorage/emptyWindowChatSessions/. VS Code keeps an index of them in its
+// state.vscdb, but that database also holds other extensions' secrets and can be large, so the list comes
+// from the files themselves. Older chats in the state.vscdb key 'interactive.sessions' are not read.
+
+/** The VS Code builds whose chats are read; forks such as Cursor have their own adapters. */
+const APPS = ["Code", "Code - Insiders"]
+
+/** Session files up to this size are parsed whole for the list; bigger ones (tens of MB happen) are peeked at. */
+const FULL_READ_LIMIT = 4 * 1024 * 1024
+
+const oneLine = (s: string) => s.replace(/\s+/g, " ").trim()
+const titleFrom = (s: string | undefined) => (s && oneLine(s) ? oneLine(s).slice(0, 120) : undefined)
+
+/** Bytes [start, start+length) of a file as text. */
+function slice(path: string, start: number, length: number): string {
+  const fd = openSync(path, "r")
+  try {
+    const buf = Buffer.alloc(length)
+    const n = readSync(fd, buf, 0, length, Math.max(0, start))
+    return buf.subarray(0, n).toString("utf8")
+  } finally {
+    closeSync(fd)
+  }
+}
+
+/** The last JSON string literal captured by `re` in `text`, decoded. */
+function lastString(text: string, re: RegExp): string | undefined {
+  let out: string | undefined
+  for (const m of text.matchAll(re)) {
+    try {
+      out = JSON.parse(m[1]!)
+    } catch {
+      // cut off at the edge of the slice
+    }
+  }
+  return out
+}
+
+const STRING = String.raw`("(?:[^"\\]|\\.)*")`
+
+/** JSON with comments and trailing commas, as .code-workspace files are written. */
+function parseJsonc(text: string): unknown {
+  let out = ""
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i]!
+    if (c === '"') {
+      const end = text.slice(i).match(/^"(?:[^"\\]|\\.)*"/)?.[0] ?? c
+      out += end
+      i += end.length - 1
+    } else if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++
+      out += "\n"
+    } else if (c === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2)
+      i = end < 0 ? text.length : end + 1
+    } else out += c
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"))
+}
+
+/** The folder a workspace storage folder belongs to: workspace.json's folder, or a multi-root workspace's first folder. */
+function workspaceFolder(dir: string): string | undefined {
+  const w = readJson<{ folder?: unknown; workspace?: unknown }>(join(dir, "workspace.json"))
+  if (!w) return undefined
+  if (w.folder !== undefined) return uriPath(w.folder)
+  const file = uriPath(w.workspace)
+  if (!file) return undefined
+  try {
+    const first = (parseJsonc(readFileSync(file, "utf8")) as { folders?: Array<{ path?: string; uri?: string }> }).folders?.[0]
+    if (typeof first?.path === "string") return resolve(dirname(file), first.path)
+    if (typeof first?.uri === "string") return uriPath(first.uri)
+  } catch {
+    // an unreadable workspace file: the folder it sits in is the best guess
+  }
+  return dirname(file)
+}
+
+interface Summary {
+  sessionId: string
+  title?: string
+  updatedAt?: string
+  cwd?: string
+}
+
+/** Enough of a session for the list; undefined for an empty chat (VS Code hides those too). */
+function summarize(path: string): Summary | undefined {
+  const stem = path.replace(/^.*\//, "").replace(/\.jsonl?$/, "")
+  let size = 0
+  try {
+    size = statSync(path).size
+  } catch {
+    return undefined
+  }
+  if (size <= FULL_READ_LIMIT) {
+    const data = loadSession(path)?.data
+    const requests = Array.isArray(data?.requests) ? data!.requests : []
+    if (!data || !requests.length) return undefined
+    const title = titleFrom(typeof data.customTitle === "string" ? data.customTitle : undefined) ?? titleFrom(firstMessage(data))
+    const updatedAt = iso(data.lastMessageDate) ?? iso(requests[requests.length - 1]?.timestamp) ?? mtime(path)
+    const cwd = uriPath(data.workingDirectory)
+    return { sessionId: typeof data.sessionId === "string" ? data.sessionId : stem, ...(title ? { title } : {}), ...(updatedAt ? { updatedAt } : {}), ...(cwd ? { cwd } : {}) }
+  }
+  // A big file: the first request's text is near the start, the title and last date near the end (the
+  // .json writes them after the requests; the .jsonl appends title changes as Set entries).
+  const head = slice(path, 0, 256 * 1024)
+  const tail = slice(path, size - 64 * 1024, 64 * 1024)
+  const title =
+    lastString(tail, new RegExp(String.raw`"k"\s*:\s*\[\s*"customTitle"\s*\]\s*,\s*"v"\s*:\s*${STRING}`, "g")) ??
+    lastString(tail, new RegExp(String.raw`"customTitle"\s*:\s*${STRING}`, "g")) ??
+    lastString(head.slice(0, 4096), new RegExp(String.raw`"customTitle"\s*:\s*${STRING}`, "g")) ??
+    lastString(head.match(new RegExp(String.raw`"message"\s*:\s*\{[^]*?"text"\s*:\s*${STRING}`))?.[0] ?? "", new RegExp(String.raw`"text"\s*:\s*${STRING}`, "g"))
+  const last = [...tail.matchAll(/"lastMessageDate"\s*:\s*(\d+)/g)].pop()?.[1]
+  const updatedAt = iso(last ? Number(last) : undefined) ?? mtime(path)
+  return { sessionId: stem, ...(titleFrom(title) ? { title: titleFrom(title) } : {}), ...(updatedAt ? { updatedAt } : {}) }
+}
+
+/** The sessions in one chatSessions folder; when a chat has both a .json and a .jsonl, VS Code reads the .jsonl. */
+function sessionRefs(dir: string, cwd: string | undefined, extra: Record<string, unknown>): SessionRef[] {
+  const names = ls(dir).filter((n) => /\.jsonl?$/.test(n))
+  const refs: SessionRef[] = []
+  for (const name of names) {
+    if (name.endsWith(".json") && names.includes(`${name}l`)) continue
+    const path = join(dir, name)
+    const s = summarize(path)
+    if (!s) continue
+    const where = s.cwd ?? cwd
+    refs.push({ tool: TOOL, sourceId: s.sessionId, path, ...(s.title ? { title: s.title } : {}), ...(where ? { cwd: where } : {}), ...(s.updatedAt ? { updatedAt: s.updatedAt } : {}), extra })
+  }
+  return refs
+}
+
+export const reader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home) {
+    const refs: SessionRef[] = []
+    for (const app of APPS) {
+      const user = join(appSupport(home), app, "User")
+      if (!isDir(user)) continue
+      const storage = join(user, "workspaceStorage")
+      for (const hash of ls(storage)) {
+        const dir = join(storage, hash, "chatSessions")
+        if (!ls(dir).length) continue
+        refs.push(...sessionRefs(dir, workspaceFolder(join(storage, hash)), { app, workspace: hash }))
+      }
+      refs.push(...sessionRefs(join(user, "globalStorage", "emptyWindowChatSessions"), undefined, { app, emptyWindow: true }))
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref) {
+    const loaded = loadSession(ref.path)
+    if (!loaded || !Array.isArray(loaded.data.requests)) throw new Error(`${ref.path} is not a VS Code chat session`)
+    const { data, bad } = loaded
+    const lost = lossCounter()
+    // Readers feed the brief, so an unexpected version is read and flagged rather than refused.
+    if (data.version !== TESTED_VERSION) lost.add(`unverified session format version ${String(data.version)}`)
+    if (bad) lost.add("unreadable log lines", bad)
+    const cwd = uriPath(data.workingDirectory) ?? ref.cwd
+    const requests: Array<Record<string, any>> = data.requests.filter((r: unknown) => typeof r === "object" && r !== null)
+    // The extension version is recorded on requests by newer builds; the latest one wrote the session last.
+    const version = requests.map((r) => r.agent?.extensionVersion).filter((v) => typeof v === "string").pop()
+    const title = titleFrom(typeof data.customTitle === "string" ? data.customTitle : undefined) ?? titleFrom(firstMessage(data))
+    const startedAt = iso(data.creationDate) ?? iso(requests[0]?.timestamp)
+    const updatedAt = iso(data.lastMessageDate) ?? iso(requests[requests.length - 1]?.timestamp) ?? mtime(ref.path)
+    const h = header(TOOL, typeof data.sessionId === "string" ? data.sessionId : ref.sourceId, {
+      ...(version ? { toolVersion: version } : {}),
+      sourcePath: ref.path,
+      ...(title ? { title } : {}),
+      project: { ...(cwd ? { cwd } : {}), ...gitInfo(cwd) },
+      ...(startedAt ? { startedAt } : {}),
+      ...(updatedAt ? { updatedAt } : {}),
+    })
+    // A chat this tool's writer made says where it came from in its first request's rendered message.
+    for (const req of requests) {
+      const rendered = req.result?.metadata?.renderedUserMessage
+      const text = req.isSystemInitiated ? req.message?.text : Array.isArray(rendered) ? rendered.map((p: Record<string, unknown>) => (typeof p?.text === "string" ? p.text : "")).join("") : undefined
+      const from = typeof text === "string" ? text.match(CONTINUED_NOTE)?.[1] : undefined
+      if (from) {
+        h.parent = { id: from, kind: "continued" }
+        break
+      }
+    }
+    const ctx: Ctx = { h, lost, ids: new Set() }
+    const turns: Turn[] = []
+    for (const req of requests) {
+      // Hidden requests were undone (restored to an earlier checkpoint) and are no longer part of the chat.
+      if (req.isHidden || req.hiddenFromTranscript || req.shouldBeRemovedOnSend) {
+        lost.add("undone requests")
+        continue
+      }
+      turns.push(...requestTurns(req, data, ctx))
+    }
+    if (Array.isArray(data.pendingRequests) && data.pendingRequests.length) lost.add("queued requests not yet sent", data.pendingRequests.length)
+    lost.flush(h)
+    return { header: h, turns }
+  },
+}
+

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

@@ -0,0 +1,388 @@
+import { readFileSync } from "node:fs"
+import { keepImage } from "../../session/attachments.ts"
+import type { Attachment, SessionHeader, Turn, Usage } from "../../session/types.ts"
+import { asText, clip, iso, noteModel, toolKindOf, type lossCounter } from "../../session/util.ts"
+
+// Facts about VS Code's chat session files (ISerializableChatData), shared by the reader. Checked against
+// the 82 version-3 .json sessions on this Mac (VS Code up to 1.144, Copilot Chat 0.35) and against
+// microsoft/vscode main: chatModel.ts, chatSessionOperationLog.ts and objectMutationLog.ts, which define
+// the .jsonl mutation log that 1.109 and later write. See docs/sessions/2026-11-08-session-formats.md,
+// entry 33.
+
+export const TOOL = "vscode-copilot"
+export const LABEL = "Copilot Chat in VS Code"
+
+/** The session format version this reader was checked against. */
+export const TESTED_VERSION = 3
+
+type Lost = ReturnType<typeof lossCounter>
+type Json = Record<string, any>
+
+const isObj = (v: unknown): v is Json => typeof v === "object" && v !== null && !Array.isArray(v)
+// Keys a log entry must never walk into: they would reach Object.prototype.
+const UNSAFE = new Set(["__proto__", "constructor", "prototype"])
+
+/**
+ * Rebuilds a session from VS Code's append-only mutation log (ObjectMutationLog): {kind: 0, v} sets the
+ * whole state, {kind: 1, k: path, v} sets a value at a path, {kind: 2, k, v?, i?} truncates the array at
+ * `k` to `i` items and pushes `v`, {kind: 3, k} deletes. The log compacts itself back to one kind-0 line
+ * from time to time. Lines that are not JSON, or that point nowhere, are counted as `bad` and skipped.
+ */
+export function replayLog(text: string): { state: Json | undefined; bad: number } {
+  let state: unknown
+  let bad = 0
+  const parentOf = (path: unknown[]): Json | unknown[] | undefined => {
+    let cur: unknown = state
+    for (const seg of path.slice(0, -1)) {
+      if (UNSAFE.has(String(seg)) || (typeof cur !== "object" || cur === null)) return undefined
+      cur = (cur as Json)[seg as string]
+    }
+    return typeof cur === "object" && cur !== null ? (cur as Json) : undefined
+  }
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue
+    let e: Json
+    try {
+      e = JSON.parse(line)
+    } catch {
+      bad++
+      continue
+    }
+    if (e?.kind === 0) {
+      state = e.v
+      continue
+    }
+    const k = e?.k
+    if (state === undefined || !Array.isArray(k) || ![1, 2, 3].includes(e.kind)) {
+      bad++
+      continue
+    }
+    if (!k.length) {
+      // A changed key field replaces the whole object at its path; at the root that is the session.
+      if (e.kind === 1) state = e.v
+      else bad++
+      continue
+    }
+    const parent = parentOf(k)
+    const last = String(k[k.length - 1])
+    if (!parent || UNSAFE.has(last)) {
+      bad++
+      continue
+    }
+    const p = parent as Json
+    if (e.kind === 1) p[last] = e.v
+    else if (e.kind === 3) delete p[last]
+    else {
+      const arr: unknown[] = Array.isArray(p[last]) ? p[last] : []
+      if (typeof e.i === "number") arr.length = Math.min(arr.length, e.i)
+      if (Array.isArray(e.v)) for (const x of e.v) arr.push(x)
+      p[last] = arr
+    }
+  }
+  return { state: isObj(state) ? state : undefined, bad }
+}
+
+/** A session file read whole: a .json document, or a .jsonl log replayed. */
+export function loadSession(path: string): { data: Json; bad: number } | undefined {
+  let text: string
+  try {
+    text = readFileSync(path, "utf8")
+  } catch {
+    return undefined
+  }
+  if (path.endsWith(".jsonl")) {
+    const r = replayLog(text)
+    return r.state ? { data: r.state, bad: r.bad } : undefined
+  }
+  try {
+    const data = JSON.parse(text)
+    return isObj(data) ? { data, bad: 0 } : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** A local path from a file:// URI string or a serialised URI ({scheme, path, fsPath}); undefined for remote ones. */
+export function uriPath(u: unknown): string | undefined {
+  if (typeof u === "string") {
+    if (!u.startsWith("file://")) return undefined
+    try {
+      return decodeURIComponent(new URL(u).pathname)
+    } catch {
+      return undefined
+    }
+  }
+  if (isObj(u)) {
+    if (u.scheme !== undefined && u.scheme !== "file") return undefined
+    if (typeof u.fsPath === "string") return u.fsPath
+    if (typeof u.path === "string") return u.path
+    if (isObj(u.uri)) return uriPath(u.uri)
+  }
+  return undefined
+}
+
+/** Text of a string or a MarkdownString ({value}). */
+const mdText = (v: unknown): string => (typeof v === "string" ? v : isObj(v) && typeof v.value === "string" ? v.value : "")
+
+/** The text in a prompt-tsx element tree (LanguageModelPromptTsxPart), which tools such as read_file return. */
+function tsxText(node: unknown, depth = 0): string {
+  if (!isObj(node) || depth > 64) return ""
+  let s = typeof node.text === "string" ? `${node.lineBreakBefore ? "\n" : ""}${node.text}` : ""
+  if (Array.isArray(node.children)) for (const c of node.children) s += tsxText(c, depth + 1)
+  return s
+}
+
+/** A tool result as the model saw it (toolCallResults[id].content: text parts, prompt-tsx parts, data parts). */
+function resultContent(r: unknown): { text: string; binary: number } {
+  const parts = isObj(r) && Array.isArray(r.content) ? r.content : []
+  const out: string[] = []
+  let binary = 0
+  for (const p of parts) {
+    if (!isObj(p)) continue
+    if (typeof p.value === "string") out.push(p.value)
+    else if (isObj(p.value) && "node" in p.value) out.push(tsxText(p.value.node))
+    else if (p.data !== undefined || p.mimeType !== undefined) binary++
+    else out.push(asText(p.value))
+  }
+  return { text: out.join("\n"), binary }
+}
+
+/** Tool arguments are a JSON string in toolCallRounds; keep them as an object when they parse. */
+function args(raw: unknown): unknown {
+  if (typeof raw !== "string") return raw ?? {}
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return { arguments: raw }
+  }
+}
+
+/** The model a request used: its modelId when recorded, else the name in result.details ("GPT-4.1 • 1x"). */
+function requestModel(req: Json, session: Json): string | undefined {
+  if (typeof req.modelId === "string" && req.modelId) return req.modelId
+  const d = req.result?.details
+  if (typeof d === "string" && d.trim()) return d.split(" • ")[0]!.trim()
+  const sel = session.selectedModel?.identifier ?? session.inputState?.selectedModel?.identifier
+  return typeof sel === "string" ? sel : undefined
+}
+
+function attachmentsOf(req: Json, lost: Lost): Attachment[] {
+  const out: Attachment[] = []
+  const vars = req.variableData?.variables
+  for (const v of Array.isArray(vars) ? vars : []) {
+    if (!isObj(v)) continue
+    if (v.isImage || v.kind === "image") {
+      // Pasted images are stored inline as {$base64} bytes with a mimeType; any other form stays behind.
+      const b64 = isObj(v.value) && typeof v.value.$base64 === "string" ? v.value.$base64 : undefined
+      const kept = b64 ? keepImage(b64, typeof v.mimeType === "string" ? v.mimeType : undefined) : undefined
+      if (kept) out.push({ ...kept, ...(typeof v.name === "string" ? { name: v.name } : {}) })
+      else {
+        out.push({ kind: "image", ...(typeof v.name === "string" ? { name: v.name } : {}) })
+        lost.add("image bytes")
+      }
+      continue
+    }
+    const path = uriPath(v.value)
+    if (path) out.push({ kind: "file", path, ...(typeof v.name === "string" ? { name: v.name } : {}) })
+  }
+  return out
+}
+
+// Response parts that only drive the chat UI (progress, links, buttons, edit bookkeeping): nothing a model
+// needs to carry on. Parts not listed here and not handled below are counted as unknown.
+const UI_PARTS = new Set([
+  "codeblockUri", "undoStop", "progressMessage", "progressTask", "progressTaskSerialized", "warning", "info", "confirmation",
+  "command", "mcpServersStarting", "prepareToolInvocation", "extensions", "pullRequest", "treeData", "markdownVuln", "hook",
+  "systemNotification", "clearToPreviousToolInvocation", "elicitationSerialized", "questionCarousel", "autoModeResolution",
+  "planReview", "multiDiffData", "workspaceEdit", "externalEdit", "disabledClaudeHooks", "notebookEditGroup", "codeCitation",
+])
+
+export interface Ctx {
+  h: SessionHeader
+  lost: Lost
+  /** Tool call ids already used in this session. */
+  ids: Set<string>
+}
+
+function uniqueId(ctx: Ctx, id: unknown): string {
+  const base = typeof id === "string" && id ? id : `vscode_call_${ctx.ids.size + 1}`
+  let out = base
+  for (let i = 2; ctx.ids.has(out); i++) out = `${base}#${i}`
+  ctx.ids.add(out)
+  return out
+}
+
+function resultTurn(callId: string, text: string, ok: boolean, at?: string): Turn {
+  const c = clip(text)
+  return { kind: "tool_result", ...(at ? { at } : {}), callId, ok, output: c.text, ...(c.truncated ? { truncated: true } : {}) }
+}
+
+/** Readable thinking, or a count in lost when it is encrypted or redacted. */
+function thinkingTurn(t: unknown, ctx: Ctx, at?: string): Turn | undefined {
+  if (!isObj(t)) return undefined
+  if (t.encrypted || t.signature) ctx.lost.add("signed or encrypted reasoning")
+  if (t.redacted) return undefined
+  const text = Array.isArray(t.text) ? t.text.join("") : typeof t.text === "string" ? t.text : Array.isArray(t.value) ? t.value.join("") : typeof t.value === "string" ? t.value : ""
+  return text.trim() ? { kind: "reasoning", ...(at ? { at } : {}), text } : undefined
+}
+
+/**
+ * The agent's own record of a request, when it kept one: result.metadata.toolCallRounds, one per model
+ * call, each with the text the model wrote and the tools it called, and toolCallResults by call id. This
+ * is the conversation the model saw; the response parts are its rendering (edits shown as code blocks,
+ * links in place of file names), and their tool ids are the UI's own, not the model's.
+ */
+function roundTurns(req: Json, rounds: Json[], model: string | undefined, ctx: Ctx): Turn[] {
+  const out: Turn[] = []
+  const meta = isObj(req.result?.metadata) ? req.result.metadata : {}
+  const results: Json = isObj(meta.toolCallResults) ? meta.toolCallResults : {}
+  // "Summarized conversation history": a summary that replaced the history up to a round, perhaps one
+  // in an earlier request; it goes after that round, or first when the round is not in this request.
+  const summaries = (Array.isArray(meta.summaries) ? meta.summaries : isObj(meta.summary) ? [meta.summary] : []).filter((x: unknown) => isObj(x) && typeof x.text === "string" && x.text.trim())
+  const roundIds = new Set(rounds.map((r) => r.id))
+  for (const s of summaries) if (s.toolCallRoundId === undefined || !roundIds.has(s.toolCallRoundId)) out.push({ kind: "compaction", summary: s.text })
+  for (const round of rounds) {
+    const m = typeof round.modelId === "string" ? round.modelId : model
+    noteModel(ctx.h, m)
+    const r = thinkingTurn(round.thinking, ctx)
+    if (r) out.push(r)
+    // Provider-side compaction state (OpenAI Responses) is opaque and stays with that provider.
+    if (round.compaction !== undefined && round.compaction !== null) ctx.lost.add("opaque compaction state")
+    if (typeof round.response === "string" && round.response.trim()) out.push({ kind: "assistant", text: round.response, ...(m ? { model: m } : {}) })
+    const calls = (Array.isArray(round.toolCalls) ? round.toolCalls : []).filter(isObj)
+    const ids = calls.map((c) => uniqueId(ctx, c.id))
+    calls.forEach((c, i) => {
+      const name = typeof c.name === "string" ? c.name : "unknown"
+      out.push({ kind: "tool_call", id: ids[i]!, name, toolKind: toolKindOf(name), input: args(c.arguments) })
+    })
+    calls.forEach((c, i) => {
+      const res = typeof c.id === "string" && Object.hasOwn(results, c.id) ? results[c.id] : undefined
+      if (res === undefined) {
+        ctx.lost.add("tool results not recorded")
+        out.push(resultTurn(ids[i]!, "(no result recorded)", false))
+        return
+      }
+      const { text, binary } = resultContent(res)
+      if (binary) ctx.lost.add("binary tool output")
+      // Copilot's tools report failure in their text ("ERROR: …", "Error: …"), not in a status field.
+      out.push(resultTurn(ids[i]!, text, !/^\s*error\b/i.test(text)))
+    })
+    for (const s of summaries) if (s.toolCallRoundId !== undefined && s.toolCallRoundId === round.id) out.push({ kind: "compaction", summary: s.text })
+  }
+  return out
+}
+
+/** A tool shown in the response without the agent's own record: name, input and output as the UI kept them. */
+function invocationTurns(p: Json, ctx: Ctx): Turn[] {
+  const data = isObj(p.toolSpecificData) ? p.toolSpecificData : {}
+  // Before toolId was kept, the UI's message is all that names a tool: 'Using "Fetch Web Page"', or a
+  // verb ("Reading …") that names none.
+  const shown = mdText(p.invocationMessage).match(/^Using "([^"]+)"/)?.[1]
+  const name = typeof p.toolId === "string" && p.toolId ? p.toolId : data.kind === "terminal" ? "run_in_terminal" : (shown ?? "copilot_tool")
+  const details = p.resultDetails
+  let input: unknown
+  if (data.kind === "terminal") input = { command: data.commandLine?.original ?? data.commandLine?.userEdited ?? data.command }
+  else if (data.kind === "input") input = data.rawInput
+  else if (isObj(details) && typeof details.input === "string") input = args(details.input)
+  else input = { description: mdText(p.invocationMessage) }
+  const id = uniqueId(ctx, p.toolCallId)
+  const started = iso(p.startedAt)
+  let output: string
+  if (isObj(details) && details.output !== undefined) output = asText(details.output)
+  else if (Array.isArray(details)) output = details.map((d) => uriPath(d) ?? uriPath(isObj(d) ? d.uri : undefined) ?? asText(d)).join("\n")
+  else output = mdText(p.pastTenseMessage) || mdText(p.invocationMessage)
+  // isConfirmed was a boolean before 1.104 and is now a reason; types 0 and 5 are Denied and Skipped.
+  const denied = p.isConfirmed === false || (isObj(p.isConfirmed) && (p.isConfirmed.type === 0 || p.isConfirmed.type === 5))
+  const ok = p.isComplete !== false && !denied && !p.resultError
+  return [
+    { kind: "tool_call", ...(started ? { at: started } : {}), id, name, toolKind: toolKindOf(name), input: input ?? {} },
+    resultTurn(id, p.resultError ? `${asText(p.resultError)}\n${output}`.trim() : output, ok, iso(p.completedAt)),
+  ]
+}
+
+/** The response parts in order: markdown becomes assistant text, tools become calls and results, thinking becomes reasoning. */
+function partTurns(parts: unknown[], model: string | undefined, ctx: Ctx): Turn[] {
+  const out: Turn[] = []
+  let text = ""
+  const flush = () => {
+    if (text.trim()) out.push({ kind: "assistant", text, ...(model ? { model } : {}) })
+    text = ""
+  }
+  for (const p of parts) {
+    if (!isObj(p)) continue
+    const kind = p.kind
+    if (kind === undefined || kind === null || kind === "markdownContent") text += mdText(kind === "markdownContent" ? p.content : p)
+    else if (kind === "inlineReference") {
+      // A file or symbol link inside the text; keep its name so the sentence still reads.
+      const ref = p.inlineReference
+      const name = typeof p.name === "string" ? p.name : isObj(ref) && typeof ref.name === "string" ? ref.name : (uriPath(ref)?.split("/").pop() ?? "")
+      text += name ? `\`${name}\`` : ""
+    } else if (kind === "thinking") {
+      flush()
+      const r = thinkingTurn(p, ctx)
+      if (r) out.push(r)
+    } else if (kind === "toolInvocationSerialized") {
+      flush()
+      out.push(...invocationTurns(p, ctx))
+    } else if (kind === "textEditGroup") {
+      flush()
+      const path = uriPath(p.uri)
+      if (path) out.push({ kind: "file_edit", path })
+    } else if (!UI_PARTS.has(kind)) ctx.lost.add(`unknown record types: ${String(kind)}`)
+  }
+  flush()
+  return out
+}
+
+/** One request: the person's message, then the reply (from the agent's rounds when it kept them). */
+export function requestTurns(req: Json, session: Json, ctx: Ctx): Turn[] {
+  const out: Turn[] = []
+  const at = iso(req.timestamp)
+  const text = typeof req.message?.text === "string" ? req.message.text : ""
+  const attachments = attachmentsOf(req, ctx.lost)
+  // A system-initiated request is a notification the chat shows (a terminal finishing, a summary), not the person's words.
+  if ((text.trim() || attachments.length) && !req.isSystemInitiated) out.push({ kind: "user", ...(at ? { at } : {}), text, ...(attachments.length ? { attachments } : {}) })
+  const model = requestModel(req, session)
+  // Very old sessions kept the response as one markdown string; VS Code reads it the same way.
+  const parts: unknown[] = Array.isArray(req.response) ? req.response : typeof req.response === "string" ? [{ value: req.response }] : []
+  const rounds = req.result?.metadata?.toolCallRounds
+  let reply: Turn[]
+  if (Array.isArray(rounds) && rounds.length) {
+    reply = roundTurns(req, rounds.filter(isObj), model, ctx)
+    // Edits the UI recorded, so the files a request changed are known even though its tool ids differ.
+    const seen = new Set<string>()
+    for (const p of parts) {
+      const path = isObj(p) && p.kind === "textEditGroup" ? uriPath(p.uri) : undefined
+      if (path && !seen.has(path)) {
+        seen.add(path)
+        reply.push({ kind: "file_edit", path })
+      }
+    }
+  } else {
+    noteModel(ctx.h, model)
+    reply = partTurns(parts, model, ctx)
+  }
+  // Newer versions keep token counts per request; they belong to the reply's last model turn.
+  const usage: Usage = {}
+  if (typeof req.promptTokens === "number") usage.input = req.promptTokens
+  if (typeof req.completionTokens === "number") usage.output = req.completionTokens
+  const last = [...reply].reverse().find((t) => t.kind === "assistant") as Extract<Turn, { kind: "assistant" }> | undefined
+  if (last) {
+    if (Object.keys(usage).length) last.usage = usage
+    const done = iso(req.modelState?.completedAt ?? req.responseTimestamp)
+    if (done) last.at = done
+  }
+  // A cancelled request (modelState 2) is one the person stopped or moved on from, not a failure.
+  if (req.result?.errorDetails && req.modelState?.value !== 2) ctx.lost.add("failed responses")
+  out.push(...reply)
+  return out
+}
+
+/** Text of the first request, the usual title of a chat. */
+export function firstMessage(data: Json): string | undefined {
+  for (const r of Array.isArray(data.requests) ? data.requests : []) {
+    const t = r?.message?.text
+    if (typeof t === "string" && t.trim()) return t
+  }
+  return undefined
+}