@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/cursor-ide/workspaces.ts

@@ -0,0 +1,119 @@
+import { statSync } from "node:fs"
+import { join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { exists, ls, readJson } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import { slugOf } from "./transcripts.ts"
+
+// Which folder a Cursor composer ran in. A composer records it only sometimes (workspaceIdentifier.uri on
+// newer ones), so the reader falls back, cheapest first: the workspace hash → workspaceStorage/<hash>/
+// workspace.json; the transcript folder's slug; and last the per-workspace databases whose ItemTable
+// lists the composer (757 of them on the Mac this was written on: about a second, so done once per list
+// and only for composers nothing else placed).
+
+/** A folder path from a VS Code-style URI; undefined for remote or non-file URIs. */
+export function folderFromUri(uri: unknown): string | undefined {
+  if (typeof uri !== "string" || !uri.startsWith("file:")) return undefined
+  try {
+    return fileURLToPath(uri)
+  } catch {
+    return undefined
+  }
+}
+
+export class Workspaces {
+  private byHash = new Map<string, string | undefined>()
+  private all?: Map<string, string>
+  private scanned = new Map<string, string>()
+  private scannedDbs = new Set<string>()
+
+  constructor(private readonly storage: string) {}
+
+  /** The folder of one workspace hash, from its workspace.json (a .code-workspace or empty window has none). */
+  folder(hash: string | undefined): string | undefined {
+    if (!hash) return undefined
+    if (!this.byHash.has(hash)) this.byHash.set(hash, folderFromUri(readJson<{ folder?: string }>(join(this.storage, hash, "workspace.json"))?.folder))
+    return this.byHash.get(hash)
+  }
+
+  /**
+   * Whether the composer's own record names its workspace. That answer is final even when it has no
+   * folder (an empty window, a .code-workspace, a workspace whose storage is gone): scanning the other
+   * workspaces cannot place a composer that belongs to none of them.
+   */
+  known(hash: string | undefined): boolean {
+    return !!hash
+  }
+
+  /** Every folder Cursor has opened as a workspace, from each workspace.json (read once). */
+  folders(): string[] {
+    if (!this.all) {
+      this.all = new Map()
+      for (const hash of ls(this.storage)) {
+        const f = this.folder(hash)
+        if (f) this.all.set(slugOf(f), f)
+      }
+    }
+    return [...this.all.values()]
+  }
+
+  /** The folder whose transcript slug is `slug`. */
+  bySlug(slug: string): string | undefined {
+    this.folders()
+    return this.all!.get(slug)
+  }
+
+  /**
+   * Folders for composers listed in a workspace's ItemTable (composer.composerData.allComposers), newest
+   * workspace first, stopping once every wanted composer is placed. Index entries may point at composers
+   * that no longer exist (the catalogue counted 957 entries for 64 composers); only wanted ids are kept.
+   */
+  listing(wanted: Iterable<string>): Map<string, string> {
+    const want = new Set(wanted)
+    const out = new Map<string, string>()
+    if (!want.size) return out
+    for (const id of want) {
+      const f = this.scanned.get(id)
+      if (f) {
+        out.set(id, f)
+        want.delete(id)
+      }
+    }
+    const dbs = ls(this.storage)
+      .map((hash) => ({ hash, db: join(this.storage, hash, "state.vscdb") }))
+      .filter((w) => !this.scannedDbs.has(w.hash) && exists(w.db) && this.folder(w.hash))
+      .map((w) => ({ ...w, t: statSync(w.db).mtimeMs }))
+      .sort((a, b) => b.t - a.t)
+    for (const w of dbs) {
+      if (!want.size) break
+      this.scannedDbs.add(w.hash)
+      let ids: string[] = []
+      try {
+        ids = withSnapshot(w.db, (db) => {
+          const row = db.query("SELECT value FROM ItemTable WHERE key = 'composer.composerData'").get() as { value: unknown } | null
+          const v = row ? parse(row.value) : undefined
+          return Array.isArray(v?.allComposers) ? v.allComposers.map((c: { composerId?: unknown }) => String(c?.composerId ?? "")) : []
+        })
+      } catch {
+        continue // a damaged or foreign database: skip it, it only helps place composers
+      }
+      const folder = this.folder(w.hash)!
+      for (const id of ids) {
+        this.scanned.set(id, folder)
+        if (want.delete(id)) out.set(id, folder)
+      }
+    }
+    return out
+  }
+}
+
+/** JSON from a SQLite value, which Cursor stores as TEXT or as a BLOB of UTF-8. */
+export function parse(v: unknown): any {
+  try {
+    if (typeof v === "string") return JSON.parse(v)
+    if (v instanceof Uint8Array) return JSON.parse(new TextDecoder().decode(v))
+  } catch {
+    /* not JSON */
+  }
+  return undefined
+}

package/src/adapters/cursor-ide/writer.ts

@@ -0,0 +1,170 @@
+import { randomUUID } from "node:crypto"
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { appSupport, exists, gitInfo, isDir } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { countTurns, firstUserText, unpaired } from "../../session/util.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import { claudeCodeReader } from "../claude-code/reader.ts"
+import { TESTED as CLAUDE_TESTED, claudeVersion, projectSlug, projectsDir } from "../claude-code/records.ts"
+import { planTranscript } from "../claude-code/writer.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+
+// Continues a portable session in Cursor through Cursor's own Claude Code import. Cursor 3.27's Agents
+// window lists the Claude Code transcripts of each open workspace (setting "Import Claude Code
+// Conversations"), and when the person sends a follow-up to one, Cursor builds a real Cursor chat from it
+// itself: its conversation state, blobs, bubbles and sidebar entry, with the whole history as the model's
+// context. So this writer only writes a Claude Code transcript where that importer looks, shaped to its
+// rules (read from Cursor 3.27.22's workbench.glass.main.js):
+//
+// - folder: ~/.claude/projects/ + the workspace path with only "/" replaced by "-" (Claude Code replaces
+//   every non-alphanumeric, so for a path with ".", "_" or spaces the two differ; the file goes where
+//   Cursor looks, and Claude Code then does not list it);
+// - the first `cwd` in the file must equal the workspace path exactly, and the head of the file must be
+//   valid JSON lines;
+// - the title is the `ai-title` record, else the first prompt;
+// - records are read in file order, ignoring parentUuid, compaction boundaries and isCompactSummary, so a
+//   compacted session is written from its last summary on (as a plain first message) rather than as a
+//   boundary Cursor would not honour; the turns before it would otherwise all go to the model.
+//
+// Nothing of Cursor's is written: no database, so Cursor may stay open (it polls ~/.claude/projects).
+
+export const TOOL = "cursor"
+const LABEL = "Cursor"
+
+/**
+ * Cursor versions whose importer this was checked against: 3.27.22 (rules above, read from its workbench bundle and run),
+ * and 3.29.9, whose importer (workbench.glass.main.js: parse-full / from-jsonl / identity) was re-read on 2026-11-08 and
+ * follows the same rules: first `cwd` of the file, `user`/`assistant` records in file order, `tool_result` blocks paired to
+ * their `tool_use` by id, `ai-title` for the title, no use of parentUuid. Read, not run: Cursor was not driven.
+ */
+export const TESTED_CURSOR = /^3\.(27|29)\./
+
+const SETTING = "cursor/importClaudeCodeAgents"
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+/** The folder Cursor's importer reads for a workspace path. */
+export const cursorSlug = (cwd: string) => cwd.replace(/\//g, "-")
+
+const appPaths = (home: string) => [join(home, "Applications", "Cursor.app"), "/Applications/Cursor.app"]
+
+/** Cursor's own version (product.json "version", e.g. 3.27.22; Info.plist carries the same). */
+export function cursorVersion(home: string): string | undefined {
+  for (const app of appPaths(home)) {
+    try {
+      const v = JSON.parse(readFileSync(join(app, "Contents", "Resources", "app", "product.json"), "utf8")).version
+      if (typeof v === "string") return v
+    } catch {}
+  }
+  return undefined
+}
+
+/** Whether "Import Claude Code Conversations" is on: an application-scope key in Cursor's global store. Undefined when unknown. */
+export function importEnabled(home: string): boolean | undefined {
+  const db = join(appSupport(home), "Cursor", "User", "globalStorage", "state.vscdb")
+  if (!exists(db)) return undefined
+  try {
+    return withSnapshot(db, (d) => {
+      const row = d.query("SELECT value FROM ItemTable WHERE key = ?").get(SETTING) as { value: unknown } | null
+      if (!row) return false
+      const v = typeof row.value === "string" ? row.value : Buffer.from(row.value as Uint8Array).toString("utf8")
+      return v.trim() === "true"
+    })
+  } catch {
+    return undefined
+  }
+}
+
+/** A title of at most 60 characters, cut at a word. */
+function shortTitle(text: string): string {
+  const t = text.replace(/\s+/g, " ").trim()
+  if (t.length <= 60) return t
+  const cut = t.slice(0, 59)
+  return `${cut.slice(0, cut.lastIndexOf(" ") > 30 ? cut.lastIndexOf(" ") : 59)}…`
+}
+
+/** The session from its last compaction on, the summary as a plain first message; how many turns that leaves out. */
+export function fromLastCompaction(session: Session): { session: Session; dropped: number } {
+  const i = session.turns.map((t) => t.kind).lastIndexOf("compaction")
+  if (i < 0) return { session, dropped: 0 }
+  const c = session.turns[i] as Extract<Turn, { kind: "compaction" }>
+  const summary: Turn = {
+    kind: "user",
+    ...(c.at ? { at: c.at } : {}),
+    text: `[Summary of the earlier conversation in ${toolLabel(session.header.tool)}, which replaced the turns before it]\n\n${c.summary}`,
+  }
+  return { session: { ...session, turns: [summary, ...session.turns.slice(i + 1)] }, dropped: i }
+}
+
+/** The writer; `version`, `enabled` and `claude` are for tests, which must not depend on the installed apps. */
+export function cursorImportWriter(opts: { version?: string; enabled?: boolean; claude?: string } = {}): Writer {
+  const installed = (home: string) => opts.version ?? cursorVersion(home)
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "import",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed(w.home)
+      if (!v) return { ok: false, why: "Cursor is not installed (no Cursor.app)" }
+      if (!TESTED_CURSOR.test(v)) return { ok: false, why: `Cursor ${v} is not a version whose Claude Code import was checked (3.27.x, 3.29.x)` }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; Cursor imports sessions for the folder it has open` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      // The path exactly as Cursor has the folder open: not resolved through symlinks, unlike Claude Code's own.
+      const cwd = w.cwd.replace(/\/+$/, "") || "/"
+      const label = toolLabel(session.header.tool)
+      const { session: tail, dropped } = fromLastCompaction(session)
+      const git = gitInfo(cwd)
+      let sessionId = randomUUID()
+      const dir = join(projectsDir(w.home), cursorSlug(cwd))
+      while (exists(join(dir, `${sessionId}.jsonl`))) sessionId = randomUUID()
+      const path = join(dir, `${sessionId}.jsonl`)
+      const version = opts.claude ?? claudeVersion() ?? CLAUDE_TESTED.max
+      const plan = planTranscript(tail, { sessionId, cwd, version, gitBranch: git.gitBranch ?? (git.gitCommit ? "HEAD" : ""), now: new Date() })
+      const title = `${shortTitle(session.header.title ?? firstUserText(session) ?? "Session")} (from ${label})`
+      // Near the top: Cursor finds the title while reading the head of the file.
+      plan.lines.splice(1, 0, { type: "ai-title", aiTitle: title, sessionId })
+
+      const lost = [...plan.lost]
+      if (dropped) lost.unshift(`turns before the last compaction (${dropped}), carried by its summary`)
+      const images = session.turns.reduce((n, t) => n + (t.kind === "user" ? (t.attachments ?? []).filter((a) => a.kind === "image").length : 0), 0)
+      if (images) lost.push(`images (${images}; Cursor's import keeps text only)`)
+
+      if (!w.dryRun) {
+        mkdirSync(dir, { recursive: true })
+        writeFileSync(path, `${plan.lines.map((l) => JSON.stringify(l)).join("\n")}\n`, { flag: "wx" })
+        const back = await claudeCodeReader.read({ tool: "claude-code", sourceId: sessionId, path }, w.home)
+        const pairs = unpaired(back)
+        const got = countTurns(back).tool_call
+        if (got !== plan.expect.calls || pairs.calls.length || pairs.results.length) {
+          rmSync(path, { force: true })
+          throw new Error(`the transcript for Cursor did not read back intact (${got} of ${plan.expect.calls} tool calls); nothing was kept`)
+        }
+      }
+
+      const enabled = opts.enabled ?? importEnabled(w.home)
+      const steps = [
+        enabled === true ? "" : `${enabled === false ? "Once" : "If not done yet"}: in Cursor's Agents window, Settings → Third-Party Imports → turn on "Import Claude Code Conversations".`,
+        `In the Agents window, open "${title}" (a Claude Code session) and send your next message: Cursor turns it into a Cursor chat with the whole history.`,
+        cursorSlug(cwd) === projectSlug(cwd) ? "Claude Code's /resume lists it too." : "",
+      ].filter(Boolean)
+      return {
+        tool: TOOL,
+        way: "import",
+        sessionId,
+        written: [path],
+        open: `open -a Cursor ${shellQuote(cwd)}`,
+        note: steps.join(" "),
+        lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const cursorWriter = cursorImportWriter()

package/src/adapters/devin/index.ts

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { devinReader } from "./reader.ts"
+import { devinWriter } from "./writer.ts"
+
+// Devin CLI (Cognition): reads every visible session of the shared sessions.db (the active branch of each), and
+// continues any session as a new native session in that store, after a backup. Ported from session-migrate (MIT).
+export const readers: Reader[] = [devinReader]
+export const writers: Writer[] = [devinWriter]

package/src/adapters/devin/reader.ts

@@ -0,0 +1,305 @@
+import type { Database } from "bun:sqlite"
+import { realpathSync } from "node:fs"
+import { exists, gitInfo } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import { keepImage, parseDataUrl } from "../../session/attachments.ts"
+import type { Attachment, Session, Turn, Usage } from "../../session/types.ts"
+import { clip, header, iso, lossCounter, noteModel } from "../../session/util.ts"
+import { CONTINUED_NOTE } from "../opencode/note.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import {
+  COMPACTION_EXT,
+  LABEL,
+  MIGRATIONS,
+  NEEDED_TO_READ,
+  PINNED_VERSION,
+  SM_SUMMARY_PREFIX,
+  SUMMARY_PREFIX,
+  TOOL,
+  appliedMigrations,
+  devinToolKind,
+  missingColumns,
+  sniffImage,
+  storeCandidates,
+} from "./records.ts"
+
+// Reads Devin CLI sessions from the shared sessions.db (records.ts), always from a copy, as Devin keeps it in
+// WAL mode. A session is the active branch of its message forest: the walk from sessions.main_chain_id up the
+// parent links. Nodes off that branch (retries, edited-away turns) are counted, not read. Devin's system and
+// context messages are counted as not carried, except the note brain's writer opens a session with.
+
+/** The stores under home, each once (two candidate paths can be the same file). */
+function stores(home: string): string[] {
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const p of storeCandidates(home)) {
+    if (!exists(p)) continue
+    let real = p
+    try {
+      real = realpathSync(p)
+    } catch {}
+    if (seen.has(real)) continue
+    seen.add(real)
+    out.push(p)
+  }
+  return out
+}
+
+export const devinReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+  async list(home) {
+    const refs: SessionRef[] = []
+    for (const db of stores(home)) {
+      try {
+        const rows = withSnapshot(db, (d) => d.query("SELECT id, title, working_directory, last_activity_at FROM sessions WHERE hidden = 0").all()) as Array<Record<string, any>>
+        for (const r of rows) {
+          const updatedAt = iso(r.last_activity_at)
+          refs.push({
+            tool: TOOL,
+            sourceId: String(r.id),
+            path: db,
+            ...(r.title ? { title: String(r.title) } : {}),
+            ...(r.working_directory ? { cwd: String(r.working_directory) } : {}),
+            ...(updatedAt ? { updatedAt } : {}),
+          })
+        }
+      } catch {
+        // A store that cannot be copied or is not Devin's lists nothing; read() says why for a session in it.
+      }
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "") || a.sourceId.localeCompare(b.sourceId))
+  },
+  async read(ref) {
+    if (!exists(ref.path)) throw new Error(`Devin store not found: ${ref.path}`)
+    return withSnapshot(ref.path, (d) => readDevin(d, ref.sourceId, ref.path))
+  },
+}
+
+const json = (s: unknown): any => {
+  try {
+    return JSON.parse(String(s))
+  } catch {
+    return undefined
+  }
+}
+const str = (v: unknown) => (typeof v === "string" && v ? v : undefined)
+const obj = (v: unknown): Record<string, any> => (v && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, any>) : {})
+const num = (v: unknown) => (typeof v === "number" && Number.isFinite(v) ? v : undefined)
+
+/** A message's text: Devin stores a string; a list of parts keeps its text parts. */
+function textOf(content: unknown): string {
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return ""
+  return content
+    .filter((p) => p?.type === "text" && typeof p.text === "string")
+    .map((p) => p.text as string)
+    .join("\n")
+}
+
+interface ChainNode {
+  node_id: number
+  parent_node_id: number | null
+  chat_message: string
+  created_at: number
+}
+
+/** The active branch, root first. Throws when its links are broken: what the conversation is would be a guess. */
+function activeChain(d: Database, id: string, tip: unknown): ChainNode[] {
+  if (typeof tip !== "number" || tip <= 0) return []
+  const rows = d
+    .query(
+      `WITH RECURSIVE chain(node_id, parent_node_id, chat_message, created_at, depth) AS (
+         SELECT node_id, parent_node_id, chat_message, created_at, 0 FROM message_nodes WHERE session_id = ?1 AND node_id = ?2
+         UNION ALL
+         SELECT m.node_id, m.parent_node_id, m.chat_message, m.created_at, c.depth + 1
+         FROM chain c JOIN message_nodes m ON m.session_id = ?1 AND m.node_id = c.parent_node_id
+         WHERE c.depth < 100000
+       )
+       SELECT node_id, parent_node_id, chat_message, created_at FROM chain ORDER BY depth DESC`,
+    )
+    .all(id, tip) as ChainNode[]
+  if (!rows.length) throw new Error(`Devin session ${id}: its active branch ends at message ${tip}, which is not in the store`)
+  const seen = new Set<number>()
+  for (const r of rows) {
+    if (seen.has(r.node_id)) throw new Error(`Devin session ${id}: its message links loop`)
+    seen.add(r.node_id)
+  }
+  if (rows[0]!.parent_node_id !== null) throw new Error(`Devin session ${id}: message ${rows[0]!.node_id} names a parent (${rows[0]!.parent_node_id}) that is not in the store`)
+  return rows
+}
+
+/** One session from an open Devin store (a snapshot, or the writer's own transaction). */
+export function readDevin(d: Database, id: string, path: string): Session {
+  const missing = missingColumns(d, NEEDED_TO_READ)
+  if (missing.length) throw new Error(`${path} is not a Devin store this reader knows (no ${missing.join(", ")})`)
+  const row = d.query("SELECT * FROM sessions WHERE id = ?").get(id) as Record<string, any> | null
+  if (!row) throw new Error(`Devin session ${id} not found in ${path}`)
+  if (row.hidden) throw new Error(`Devin session ${id} is hidden`)
+  const cwd = str(row.working_directory)
+  const startedAt = iso(row.created_at)
+  const updatedAt = iso(row.last_activity_at)
+  // Devin's rows do not say which CLI wrote them; a store with exactly the pinned migrations is that version's.
+  const pinned = JSON.stringify(appliedMigrations(d)) === JSON.stringify(MIGRATIONS)
+  const h = header(TOOL, id, {
+    sourcePath: path,
+    ...(pinned ? { toolVersion: PINNED_VERSION } : {}),
+    ...(str(row.title) ? { title: String(row.title) } : {}),
+    project: { ...(cwd ? { cwd } : {}), ...gitInfo(cwd) },
+    ...(startedAt ? { startedAt } : {}),
+    ...(updatedAt ? { updatedAt } : {}),
+  })
+  const lost = lossCounter()
+  const turns: Turn[] = []
+  const chain = activeChain(d, id, row.main_chain_id)
+  const total = (d.query("SELECT count(*) AS n FROM message_nodes WHERE session_id = ?").get(id) as { n: number }).n
+  if (total > chain.length) lost.add("messages on abandoned branches (retries, edits)", total - chain.length)
+
+  // The ACP view of each call Devin keeps beside the messages: its kind, its final status, the diffs it showed.
+  const states = new Map<string, { call: Record<string, any>; update: Record<string, any> }>()
+  try {
+    for (const s of d.query("SELECT tool_call_id, tool_call_json, tool_call_update_json FROM tool_call_state WHERE session_id = ?").all(id) as Array<Record<string, any>>)
+      states.set(String(s.tool_call_id), { call: obj(json(s.tool_call_json)), update: obj(json(s.tool_call_update_json)) })
+  } catch {
+    // A store without tool_call_state still has every call and result in its messages.
+  }
+  const shown = new Map<string, Record<string, any>>()
+
+  const fallbackModel = str(row.model)
+  const byNative = new Map<string, string>()
+  const callIds = new Set<string>()
+  const answered = new Set<string>()
+
+  for (const node of chain) {
+    const m = obj(json(node.chat_message))
+    if (!m.role) {
+      lost.add("unreadable messages")
+      continue
+    }
+    const meta = obj(m.metadata)
+    const ext = obj(meta.extensions)
+    const at = iso(meta.created_at) ?? iso(node.created_at)
+    const stamp = at ? { at } : {}
+    const text = textOf(m.content)
+
+    if (m.role === "system") {
+      if (ext[COMPACTION_EXT] === true) {
+        turns.push({ kind: "compaction", ...stamp, summary: text.startsWith(SUMMARY_PREFIX) ? text.slice(SUMMARY_PREFIX.length) : text })
+        continue
+      }
+      const continued = text.match(CONTINUED_NOTE)?.[1]
+      if (continued) h.parent ??= { id: continued, kind: "continued" }
+      else lost.add("Devin system prompt and context (not carried)")
+      continue
+    }
+
+    if (m.role === "user") {
+      // session-migrate's writer stores a compaction as a flagged user message.
+      if (ext[COMPACTION_EXT] === true || (meta.session_migrate_compaction === true && text.startsWith(SM_SUMMARY_PREFIX))) {
+        const prefix = text.startsWith(SUMMARY_PREFIX) ? SUMMARY_PREFIX : text.startsWith(SM_SUMMARY_PREFIX) ? SM_SUMMARY_PREFIX : ""
+        turns.push({ kind: "compaction", ...stamp, summary: text.slice(prefix.length) })
+        continue
+      }
+      if (meta.is_user_input === false) {
+        lost.add("messages Devin injected as the user")
+        continue
+      }
+      const attachments: Attachment[] = []
+      const images = Array.isArray(m.images) ? (m.images as Array<Record<string, any>>) : []
+      for (const img of images) {
+        const data = str(img.base64_data)
+        const bytes = data ? Buffer.from(data, "base64") : undefined
+        const mime = str(img.mime_type) ?? str(img.media_type) ?? (bytes ? sniffImage(bytes) : undefined)
+        const kept = data ? keepImage(data, mime) : undefined
+        if (kept) attachments.push(kept)
+        else lost.add("images (too large or of an unknown type)")
+        if (str(img.caption)) lost.add("image captions Devin wrote")
+      }
+      if (Array.isArray(m.content))
+        for (const p of m.content as Array<Record<string, any>>) {
+          if (p?.type === "text") continue
+          const url = p?.type === "image_url" ? parseDataUrl(p.image_url?.url ?? p.image_url) : undefined
+          const kept = url ? keepImage(url.base64, url.mime) : undefined
+          if (kept) attachments.push(kept)
+          else lost.add(p?.type === "image_url" || p?.type === "image" ? "images (too large or of an unknown type)" : "message parts of other types")
+        }
+      // What the person attached through ACP besides images (documents, audio, video): Devin keeps the bytes
+      // in the message's metadata and only a marker ("[Binary resource: …]", "[Audio content]") in its text.
+      const blocks = Array.isArray(ext["chisel/acp-content-blocks"]) ? (ext["chisel/acp-content-blocks"] as Array<Record<string, any>>) : []
+      const others = blocks.filter((b) => !["text", "image", "resource_link"].includes(String(b?.type))).length
+      if (others) lost.add("attached documents, audio and video (only Devin's marker text is kept)", others)
+      if (text.trim() || attachments.length) turns.push({ kind: "user", ...stamp, text, ...(attachments.length ? { attachments } : {}) })
+      continue
+    }
+
+    if (m.role === "assistant") {
+      const model = str(meta.generation_model) ?? fallbackModel
+      const calls = Array.isArray(m.tool_calls) ? (m.tool_calls as Array<Record<string, any>>) : []
+      if (text.trim() || calls.length) noteModel(h, model)
+      const th = m.thinking
+      if (th && typeof th === "object") {
+        const signed = !!str(th.signature)
+        if (str(th.thinking)?.trim()) {
+          turns.push({ kind: "reasoning", ...stamp, text: th.thinking })
+          if (signed) lost.add("reasoning signatures")
+        } else if (signed || th.redacted || th.data) lost.add("signed or redacted reasoning")
+      }
+      if (text.trim()) {
+        // Devin's metrics hold the counts; num_tokens alone is the reply's output (243 of 243 in the capture).
+        const metrics = obj(meta.metrics)
+        const output = num(metrics.output_tokens) ?? num(meta.num_tokens)
+        const usage: Usage = {
+          ...(num(metrics.input_tokens) !== undefined ? { input: metrics.input_tokens } : {}),
+          ...(output !== undefined ? { output } : {}),
+          ...(num(metrics.cache_read_tokens) !== undefined ? { cacheRead: metrics.cache_read_tokens } : {}),
+          ...(num(metrics.cache_creation_tokens) !== undefined ? { cacheWrite: metrics.cache_creation_tokens } : {}),
+        }
+        turns.push({ kind: "assistant", ...stamp, text, ...(model ? { model } : {}), ...(Object.keys(usage).length ? { usage } : {}) })
+      }
+      const content = obj(ext["chisel/tool_call_content"])
+      calls.forEach((c, i) => {
+        const nativeId = String(c.id ?? "")
+        const name = str(c.name) ?? "unknown"
+        let callId = nativeId || `call-${node.node_id}-${i}`
+        for (let n = 2; callIds.has(callId); n++) callId = `${nativeId || "call"}#${n}`
+        callIds.add(callId)
+        byNative.set(nativeId, callId)
+        if (content[nativeId]) shown.set(nativeId, obj(content[nativeId]))
+        const acp = str(states.get(nativeId)?.call.kind) ?? str(obj(content[nativeId]).kind)
+        const input = typeof c.arguments === "string" ? (json(c.arguments) ?? c.arguments) : (c.arguments ?? {})
+        turns.push({ kind: "tool_call", ...stamp, id: callId, name, toolKind: devinToolKind(name, acp), input })
+      })
+      continue
+    }
+
+    if (m.role === "tool") {
+      const nativeId = String(m.tool_call_id ?? "")
+      const callId = byNative.get(nativeId)
+      if (!callId) {
+        lost.add("tool results without a call")
+        continue
+      }
+      if (answered.has(callId)) {
+        lost.add("repeated tool results")
+        continue
+      }
+      answered.add(callId)
+      const state = states.get(nativeId)
+      // Devin marks a failed call in the result's metadata and in the call's final ACP status; session-migrate's
+      // writer adds is_error to the message.
+      const failed = obj(ext["chisel/tool_result_meta"]).success === false || !!ext["chisel/tool_failure"] || m.is_error === true || state?.update.status === "failed"
+      const out = clip(text)
+      turns.push({ kind: "tool_result", ...stamp, callId, ok: !failed, output: out.text, ...(out.truncated ? { truncated: true } : {}) })
+      if (Array.isArray(m.images) && m.images.length) lost.add("images in tool results", m.images.length)
+      // Edits the call showed as ACP diffs, in its final update, its first event or the reply that made it.
+      const diffs = [state?.update.content, state?.call.content, shown.get(nativeId)?.content].flatMap((c) => (Array.isArray(c) ? (c as Array<Record<string, any>>) : []))
+      const paths = new Set(diffs.filter((x) => x?.type === "diff" && str(x.path)).map((x) => String(x.path)))
+      for (const p of paths) turns.push({ kind: "file_edit", ...stamp, path: p, callId })
+      continue
+    }
+
+    lost.add(`unknown message roles: ${String(m.role)}`)
+  }
+  lost.flush(h)
+  return { header: h, turns }
+}