@100xprompt/brain 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,501 @@
+import type { Database } from "bun:sqlite"
+import { join } from "node:path"
+import type { Session, SessionHeader, Turn, Usage } from "../../session/types.ts"
+import { appSupport, exists, gitInfo, mtime } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import { asText, clip, header, iso, lossCounter, noteModel, toolKindOf } from "../../session/util.ts"
+import type { Reader, SessionRef, Writer } from "../types.ts"
+import { bytes, composerRoot, messageOrder, toolFailed, toolResultText } from "./agentkv.ts"
+import { cliChatIds, type Loss, transcriptIndex, transcriptTurns } from "./transcripts.ts"
+import { folderFromUri, parse, Workspaces } from "./workspaces.ts"
+import { cursorWriter } from "./writer.ts"
+
+// Cursor IDE chats (catalogue entry 23 and its fact-check). One global SQLite store,
+// <appSupport>/Cursor/User/globalStorage/state.vscdb, in WAL mode, read only through a snapshot. In its
+// cursorDiskKV table each chat ("composer") is a composerData:<id> JSON document whose
+// fullConversationHeadersOnly is the only record of message order, and each message is a
+// bubbleId:<id>:<bubbleId> JSON document: type 1 user, type 2 assistant. An assistant bubble holds at most
+// one tool call together with its result (toolFormerData), and its thinking as {text, signature}: only
+// the text form is readable. Newer composers (_v 18) also point into agentKv blobs (AI-SDK messages plus
+// protobuf, agentkv.ts). The bubbles carry the conversation, but from _v 18 many tool results in them are
+// only metadata (a line count, content ids), so what the model was shown is taken from the agentKv tool
+// messages, matched by toolCallId. Checked against composerData _v 10, 11 and 18 and bubble _v 3
+// (Cursor 3.27.22). The writer (writer.ts) goes through Cursor's own Claude Code import.
+
+const TOOL = "cursor-ide"
+
+const userDir = (home: string) => join(appSupport(home), "Cursor", "User")
+const globalDb = (home: string) => join(userDir(home), "globalStorage", "state.vscdb")
+const workspaces = (home: string) => new Workspaces(join(userDir(home), "workspaceStorage"))
+
+/** Every key that starts with `prefix` (which ends in ":"), as an index range: ";" sorts right after ":". */
+const range = (prefix: string): [string, string] => [prefix, `${prefix.slice(0, -1)};`]
+
+const hasTable = (db: Database, name: string) => !!db.query("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(name)
+
+const valueOf = (db: Database, key: string) => (db.query("SELECT value FROM cursorDiskKV WHERE key = ?").get(key) as { value: unknown } | null)?.value
+
+/** One field of one JSON value, without parsing the rest in JavaScript. */
+function field(db: Database, key: string, path: string): unknown {
+  const r = db.query("SELECT json_extract(j, ?) AS x FROM (SELECT CAST(value AS TEXT) AS j FROM cursorDiskKV WHERE key = ?) WHERE json_valid(j)").get(path, key) as { x: unknown } | null
+  return r?.x ?? undefined
+}
+
+const str = (v: unknown) => (typeof v === "string" && v ? v : undefined)
+
+// composerHeaders (3.x) indexes composers with their name, times and workspace; older stores lack it.
+interface Head {
+  workspaceId?: string
+  name?: string
+  createdAt?: unknown
+  lastUpdatedAt?: unknown
+  uri?: { scheme?: string; fsPath?: string; path?: string }
+  isSubagent?: boolean
+}
+
+function heads(db: Database): Map<string, Head> {
+  const out = new Map<string, Head>()
+  if (!hasTable(db, "composerHeaders")) return out
+  for (const r of db.query("SELECT * FROM composerHeaders").all() as Array<Record<string, any>>) {
+    const v = (parse(r.value) ?? {}) as Record<string, any>
+    out.set(String(r.composerId), {
+      workspaceId: str(r.workspaceId) ?? str(v.workspaceIdentifier?.id),
+      name: str(v.name),
+      createdAt: r.createdAt ?? v.createdAt,
+      lastUpdatedAt: r.lastUpdatedAt ?? v.lastUpdatedAt,
+      uri: v.workspaceIdentifier?.uri,
+      isSubagent: !!r.isSubagent || !!v.isSubagent,
+    })
+  }
+  return out
+}
+
+/** The folder a workspaceIdentifier.uri names, when it is a local folder. */
+function uriFolder(uri: Head["uri"] | undefined): string | undefined {
+  if (!uri || (uri.scheme && uri.scheme !== "file")) return undefined
+  return str(uri.fsPath) ?? str(uri.path)
+}
+
+/** A folder from a bubble's workspaceProjectDir (a path) or workspaceUris entry (a file URI). */
+const bubbleFolder = (v: unknown) => (typeof v === "string" ? (v.startsWith("file:") ? folderFromUri(v) : v.startsWith("/") ? v : undefined) : undefined)
+
+/** The first project folder any of a composer's bubbles records (bubbles carry it from Cursor 2.x on). */
+function projectDir(db: Database, id: string): string | undefined {
+  const r = db
+    .query(
+      `SELECT d FROM (SELECT coalesce(json_extract(j, '$.workspaceProjectDir'), json_extract(j, '$.workspaceUris[0]')) AS d
+         FROM (SELECT CAST(value AS TEXT) AS j FROM cursorDiskKV WHERE key >= ? AND key < ?) WHERE json_valid(j)) WHERE d IS NOT NULL LIMIT 1`,
+    )
+    .get(...range(`bubbleId:${id}:`)) as { d: unknown } | null
+  return bubbleFolder(r?.d)
+}
+
+/** The Cursor version that last ran on this store; composers do not record the version that wrote them. */
+function appVersion(db: Database): string | undefined {
+  if (!hasTable(db, "ItemTable")) return undefined
+  const r = db.query("SELECT CAST(value AS TEXT) AS v FROM ItemTable WHERE key IN ('releaseNotes/lastVersion', 'cursor.startupMetrics.lastVersion') LIMIT 1").get() as { v: unknown } | null
+  return str(r?.v)
+}
+
+const oneLine = (s: string) => {
+  const t = s.replace(/\s+/g, " ").trim()
+  return t.length > 80 ? `${t.slice(0, 79)}…` : t
+}
+
+// ---- list -------------------------------------------------------------------------------------------
+
+interface Found {
+  id: string
+  v?: number
+  title?: string
+  updatedAt?: string
+  cwd?: string
+  hash?: string
+  parent?: string
+  transcript?: string
+  inDb: boolean
+}
+
+const COMPOSERS = `
+  SELECT substr(key, 14) AS id,
+    json_extract(j, '$._v') AS v, json_extract(j, '$.name') AS name,
+    json_extract(j, '$.createdAt') AS createdAt, json_extract(j, '$.lastUpdatedAt') AS lastUpdatedAt,
+    json_extract(j, '$.workspaceIdentifier.id') AS wsId, json_extract(j, '$.workspaceIdentifier.uri') AS wsUri,
+    coalesce(json_array_length(j, '$.fullConversationHeadersOnly'), 0) AS n,
+    json_extract(j, '$.fullConversationHeadersOnly[0].bubbleId') AS first,
+    json_extract(j, '$.fullConversationHeadersOnly[#-1].bubbleId') AS last,
+    json_extract(j, '$.subagentInfo.parentComposerId') AS parent,
+    coalesce(json_extract(j, '$.isBestOfNSubcomposer'), 0) AS bestOfN
+  FROM (SELECT key, CAST(value AS TEXT) AS j FROM cursorDiskKV WHERE key >= 'composerData:' AND key < 'composerData;')
+  WHERE json_valid(j)`
+
+/** Composers that hold a conversation, from their headers and a few single-row lookups, never whole chats. */
+function composers(db: Database, ws: Workspaces, transcripts: Map<string, { file: string }>): Found[] {
+  if (!hasTable(db, "cursorDiskKV")) return []
+  const bubbled = new Set<string>()
+  for (const r of db.query("SELECT key FROM cursorDiskKV WHERE key >= 'bubbleId:' AND key < 'bubbleId;'").all() as Array<{ key: string }>) bubbled.add(r.key.split(":")[1] ?? "")
+  const hs = heads(db)
+  const rows = db.query(COMPOSERS).all() as Array<Record<string, any>>
+  const known = new Set(rows.map((r) => String(r.id)))
+  const out: Found[] = []
+  const lastTime = (id: string, last: unknown) =>
+    (last ? field(db, `bubbleId:${id}:${last}`, "$.createdAt") : undefined) ??
+    (db.query("SELECT max(json_extract(j, '$.createdAt')) AS t FROM (SELECT CAST(value AS TEXT) AS j FROM cursorDiskKV WHERE key >= ? AND key < ?) WHERE json_valid(j)").get(...range(`bubbleId:${id}:`)) as { t: unknown } | null)?.t
+  for (const r of rows) {
+    const id = String(r.id)
+    if (!(r.n > 0 || bubbled.has(id) || transcripts.has(id))) continue // drafts and never-used chats
+    if (r.parent && known.has(r.parent) && !r.bestOfN) continue // a subagent: it is read as part of its parent
+    const h = hs.get(id)
+    const wsUri = parse(r.wsUri)
+    const hash = str(h?.workspaceId) ?? str(r.wsId)
+    const first = r.n > 0 && r.first ? (field(db, `bubbleId:${id}:${r.first}`, "$.type") === 1 ? str(field(db, `bubbleId:${id}:${r.first}`, "$.text")) : undefined) : undefined
+    out.push({
+      id,
+      v: typeof r.v === "number" ? r.v : undefined,
+      title: str(r.name) ?? h?.name ?? (first ? oneLine(first) : undefined),
+      updatedAt: iso(r.lastUpdatedAt) ?? iso(h?.lastUpdatedAt) ?? iso(lastTime(id, r.last)) ?? iso(r.createdAt),
+      cwd: uriFolder(wsUri) ?? uriFolder(h?.uri) ?? ws.folder(hash) ?? projectDir(db, id),
+      hash,
+      parent: r.parent && r.bestOfN ? String(r.parent) : undefined,
+      inDb: true,
+    })
+  }
+  // Index entries and bubbles whose composerData is gone still hold a conversation when they have bubbles.
+  for (const id of new Set([...hs.keys(), ...bubbled])) {
+    if (known.has(id) || !(bubbled.has(id) || transcripts.has(id))) continue
+    const h = hs.get(id)
+    if (h?.isSubagent) continue
+    out.push({ id, title: h?.name, updatedAt: iso(h?.lastUpdatedAt) ?? iso(lastTime(id, undefined)), cwd: uriFolder(h?.uri) ?? ws.folder(h?.workspaceId) ?? projectDir(db, id), hash: h?.workspaceId, inDb: true })
+  }
+  return out
+}
+
+async function list(home: string): Promise<SessionRef[]> {
+  const dbPath = globalDb(home)
+  const ws = workspaces(home)
+  const transcripts = transcriptIndex(home)
+  const found = exists(dbPath) ? withSnapshot(dbPath, (db) => composers(db, ws, transcripts)) : []
+  const inDb = new Set(found.map((f) => f.id))
+  // A transcript whose composer is gone from the database is still a session (text and calls only),
+  // unless it is a Cursor CLI chat's, which the CLI reader lists from its store in full.
+  const cli = cliChatIds(home)
+  for (const [id, t] of transcripts) if (!inDb.has(id) && !cli.has(id)) found.push({ id, updatedAt: mtime(t.file), inDb: false })
+  // Place what the store did not: the transcript folder's slug, then the workspaces that list the composer.
+  // A known workspace hash is final even without a folder (an empty window or a .code-workspace).
+  for (const f of found) {
+    const t = transcripts.get(f.id)
+    if (t) f.transcript = t.file
+    if (!f.cwd && t && !ws.known(f.hash)) f.cwd = ws.bySlug(t.slug)
+  }
+  const placed = ws.listing(found.filter((f) => !f.cwd && !ws.known(f.hash)).map((f) => f.id))
+  return found
+    .map((f): SessionRef => {
+      const cwd = f.cwd ?? placed.get(f.id)
+      return {
+        tool: TOOL,
+        sourceId: f.id,
+        path: f.inDb ? dbPath : f.transcript!,
+        ...(f.title ? { title: f.title } : {}),
+        ...(cwd ? { cwd } : {}),
+        ...(f.updatedAt ? { updatedAt: f.updatedAt } : {}),
+        extra: { ...(f.v !== undefined ? { composerVersion: f.v } : {}), ...(f.hash ? { workspace: f.hash } : {}), ...(f.parent ? { forkOf: f.parent } : {}), ...(f.transcript ? { transcript: f.transcript } : {}) },
+      }
+    })
+    .sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+}
+
+// ---- read -------------------------------------------------------------------------------------------
+
+/** A JSON-string field parsed, or the value itself when it is already an object. */
+function json(v: unknown): unknown {
+  if (typeof v !== "string") return v ?? undefined
+  try {
+    return JSON.parse(v)
+  } catch {
+    return undefined
+  }
+}
+
+/** The arguments the model sent (rawArgs), else Cursor's normalised params, else whatever text there is. */
+function toolInput(t: Record<string, any>): unknown {
+  const raw = json(t.rawArgs)
+  if (raw && typeof raw === "object" && Object.keys(raw).length) return raw
+  const params = json(t.params)
+  if (params !== undefined) return params
+  return raw ?? str(t.rawArgs) ?? {}
+}
+
+// The readable part of a tool result, by the shapes Cursor's tools return: terminal output, file
+// contents, an edit's summary for the model, MCP results. Anything else stays JSON.
+const RESULT_TEXT = ["output", "contents", "resultForModel", "result", "content", "text", "message"]
+
+// Results from Cursor 3.x tools that say what happened but not what the model saw (read_file_v2 keeps a
+// line count, edit_file_v2 two content ids); the output itself is in the agentKv tool message.
+const METADATA_ONLY = new Set(["totalLinesInFile", "afterContentId", "beforeContentId"])
+const metadataOnly = (v: unknown) => !!v && typeof v === "object" && Object.keys(v).length > 0 && Object.keys(v).every((k) => METADATA_ONLY.has(k))
+
+/** The result as text, and whether it held readable output rather than only fields such as a line count. */
+function resultText(raw: unknown): { text: string; readable: boolean } {
+  if (raw === undefined || raw === null) return { text: "", readable: false }
+  const v = typeof raw === "string" ? (json(raw) ?? raw) : raw
+  if (typeof v === "string") return { text: v, readable: !!v.trim() }
+  if (!v || typeof v !== "object") return { text: asText(v), readable: true }
+  const o = v as Record<string, any>
+  const key = RESULT_TEXT.find((k) => typeof o[k] === "string")
+  let text = key ? (o[key] as string) : typeof raw === "string" ? raw : asText(raw)
+  const code = typeof o.exitCode === "number" ? o.exitCode : typeof o.exitCodeV2 === "number" ? o.exitCodeV2 : undefined
+  if (code) text += `\n[exit code ${code}]`
+  return { text, readable: !!key && !!(o[key] as string).trim() }
+}
+
+/** What each tool call returned to the model, by toolCallId, from the composer's agentKv tool messages. */
+type ModelResults = Map<string, { text: string; failed: boolean }>
+
+function modelResults(db: Database, state: unknown): ModelResults {
+  const out: ModelResults = new Map()
+  const root = composerRoot(state)
+  if (!root) return out
+  const get = db.query("SELECT value FROM cursorDiskKV WHERE key = ?")
+  const blob = (id: string) => (get.get(`agentKv:blob:${id}`) as { value: unknown } | null)?.value
+  for (const id of messageOrder(root, (id) => bytes(blob(id))) ?? []) {
+    const m = parse(blob(id)) as Record<string, any> | undefined
+    if (m?.role !== "tool" || !Array.isArray(m.content)) continue
+    for (const p of m.content) if (p?.type === "tool-result" && str(p.toolCallId)) out.set(p.toolCallId, { text: toolResultText(p), failed: toolFailed(m, p) })
+  }
+  return out
+}
+
+function errorText(e: unknown): string {
+  const v = json(e) ?? e
+  if (v && typeof v === "object") return str((v as Record<string, any>).message) ?? str((v as Record<string, any>).error) ?? asText(v)
+  return asText(v)
+}
+
+interface Ctx {
+  dbPath: string
+  ws: Workspaces
+  transcripts: Map<string, { file: string; slug: string }>
+  depth: number
+  seen: Set<string>
+}
+
+interface Read {
+  session: Session
+  /** Nothing in the store placed it and no known workspace rules it out: worth scanning the workspaces. */
+  scan: boolean
+}
+
+/** What a bubble holds that a reader keeps: its text, readable thinking and tool call. */
+function contentOf(b: Record<string, any>, bubbleId: string): string[] {
+  const out: string[] = []
+  if (typeof b.text === "string" && b.text.trim()) out.push(`text:${b.text}`)
+  const blocks: unknown[] = Array.isArray(b.allThinkingBlocks) ? [...b.allThinkingBlocks, b.thinking] : [b.thinking]
+  for (const t of blocks) {
+    const text = typeof t === "string" ? t : str((t as Record<string, any> | undefined)?.text)
+    if (text?.trim()) out.push(`thinking:${text}`)
+  }
+  const t = b.toolFormerData as Record<string, any> | undefined
+  if (t && (str(t.name) || str(t.toolCallId))) out.push(`call:${str(t.toolCallId) ?? bubbleId}`)
+  return out
+}
+
+/** Turns from one bubble, in the order they happened: thinking, the reply, the tool call, its result. */
+function bubbleTurns(b: Record<string, any>, bubbleId: string, h: SessionHeader, lost: Loss, ids: Set<string>, shownToModel: ModelResults): Turn[] {
+  const out: Turn[] = []
+  const at = iso(b.createdAt)
+  const stamp = at ? { at } : {}
+  if (b.type === 1) {
+    if (Array.isArray(b.images) && b.images.length) lost.add("images", b.images.length)
+    if (typeof b.text === "string" && b.text.trim()) out.push({ kind: "user", ...stamp, text: b.text })
+    return out
+  }
+  if (b.type !== 2) {
+    lost.add(`unknown record types: bubble type ${String(b.type)}`)
+    return out
+  }
+  const blocks: unknown[] = Array.isArray(b.allThinkingBlocks) && b.allThinkingBlocks.length ? b.allThinkingBlocks : b.thinking !== undefined && b.thinking !== null ? [b.thinking] : []
+  for (const t of blocks) {
+    const text = typeof t === "string" ? t : str((t as Record<string, any>)?.text)
+    if (text?.trim()) out.push({ kind: "reasoning", ...stamp, text })
+    else if ((t as Record<string, any>)?.signature) lost.add("signed reasoning")
+  }
+  const model = str(b.modelInfo?.modelName)
+  noteModel(h, model)
+  if (typeof b.text === "string" && b.text.trim()) {
+    const tc = b.tokenCount ?? {}
+    const usage: Usage | undefined = tc.inputTokens > 0 || tc.outputTokens > 0 ? { input: tc.inputTokens || 0, output: tc.outputTokens || 0 } : undefined
+    out.push({ kind: "assistant", ...stamp, text: b.text, ...(model ? { model } : {}), ...(usage ? { usage } : {}) })
+  }
+  const t = b.toolFormerData as Record<string, any> | undefined
+  // Placeholder toolFormerData objects (only additionalData) are common and carry no call.
+  if (t && (str(t.name) || str(t.toolCallId))) {
+    let id = str(t.toolCallId) ?? `bubble-${bubbleId}`
+    for (let n = 2; ids.has(id); n++) id = `${str(t.toolCallId) ?? `bubble-${bubbleId}`}#${n}`
+    ids.add(id)
+    const name = str(t.name) ?? `tool-${String(t.tool ?? "unknown")}`
+    out.push({ kind: "tool_call", ...stamp, id, name, toolKind: toolKindOf(name), input: toolInput(t) })
+    const res = json(t.result) as Record<string, any> | undefined
+    const shown = str(t.toolCallId) ? shownToModel.get(t.toolCallId) : undefined
+    const failed = t.status === "error" || t.status === "cancelled" || !!t.error || res?.rejected === true || !!shown?.failed
+    const r = resultText(t.result)
+    // The bubble's own output when it has one, else what the model was shown (agentKv), else the metadata.
+    let text = r.readable || !shown?.text ? r.text : shown.text
+    if (!r.readable && !shown?.text && metadataOnly(res)) lost.add("tool outputs (only metadata kept, no agentKv message)")
+    if (t.error) text = [errorText(t.error), text].filter(Boolean).join("\n")
+    if (!text) text = t.status && t.status !== "completed" ? `[${t.status}]` : "[no result recorded]"
+    const c = clip(text)
+    out.push({ kind: "tool_result", ...stamp, callId: id, ok: !failed, output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+  }
+  if (b.errorDetails) lost.add("error notices")
+  return out
+}
+
+/** One composer in full; undefined when the store knows nothing of it. */
+function readComposer(db: Database, id: string, ctx: Ctx): Read | undefined {
+  ctx.seen.add(id)
+  const data = parse(valueOf(db, `composerData:${id}`)) as Record<string, any> | undefined
+  const head = heads(db).get(id)
+  const prefix = `bubbleId:${id}:`
+  const bubbles = new Map<string, Record<string, any>>()
+  let unreadable = 0
+  for (const r of db.query("SELECT key, value FROM cursorDiskKV WHERE key >= ? AND key < ?").all(...range(prefix)) as Array<{ key: string; value: unknown }>) {
+    const b = parse(r.value)
+    if (b && typeof b === "object") bubbles.set(r.key.slice(prefix.length), b)
+    else unreadable++
+  }
+  if (!data && !head && !bubbles.size) return undefined
+
+  const lost = lossCounter()
+  const app = appVersion(db)
+  const v = typeof data?._v === "number" ? `composer v${data._v}` : undefined
+  const h = header(TOOL, id, {
+    toolVersion: app && v ? `${app} (${v})` : (app ?? v),
+    sourcePath: ctx.dbPath,
+    title: str(data?.name) ?? head?.name,
+    startedAt: iso(data?.createdAt) ?? iso(head?.createdAt),
+    updatedAt: iso(data?.lastUpdatedAt) ?? iso(head?.lastUpdatedAt),
+  })
+  const parent = str(data?.subagentInfo?.parentComposerId)
+  if (parent) h.parent = { id: `${TOOL}:${parent}`, kind: data?.isBestOfNSubcomposer ? "fork" : "subagent" }
+
+  // Bubble order comes only from fullConversationHeadersOnly. Without it (an index that lost it), fall
+  // back to the bubbles' own timestamps.
+  const order: string[] = (Array.isArray(data?.fullConversationHeadersOnly) ? data!.fullConversationHeadersOnly : []).map((x: any) => str(x?.bubbleId)).filter((x: string | undefined): x is string => !!x)
+  let ordered: Array<[string, Record<string, any>]>
+  if (order.length) {
+    ordered = []
+    let missing = 0
+    for (const b of order) {
+      const x = bubbles.get(b)
+      if (x) ordered.push([b, x])
+      else missing++
+    }
+    if (missing) lost.add(data?.conversationState ? "missing bubbles (kept only in agentKv, not rebuilt)" : "missing bubbles", missing)
+    // Bubbles outside the order are mostly empty placeholders or copies of ordered ones (the same tool
+    // call id, the same text); only those holding something the order does not are lost.
+    const inOrder = new Set(order)
+    const kept = new Set(ordered.flatMap(([bid, b]) => contentOf(b, bid)))
+    const outside = [...bubbles].filter(([bid, b]) => !inOrder.has(bid) && contentOf(b, bid).some((c) => !kept.has(c))).length
+    if (outside) lost.add("bubbles outside the conversation order", outside)
+  } else {
+    ordered = [...bubbles.entries()].sort((a, b) => String(a[1].createdAt ?? "").localeCompare(String(b[1].createdAt ?? "")))
+  }
+  if (unreadable) lost.add("unreadable bubbles", unreadable)
+
+  // Subagents ran inside this chat, after `conversationLengthAtSpawn` bubbles. Best-of-N runs are forks,
+  // listed on their own, not children.
+  const spawned = (
+    db
+      .query(
+        `SELECT substr(key, 14) AS id, json_extract(j, '$.subagentInfo.conversationLengthAtSpawn') AS at
+         FROM (SELECT key, CAST(value AS TEXT) AS j FROM cursorDiskKV WHERE key >= 'composerData:' AND key < 'composerData;')
+         WHERE json_valid(j) AND json_extract(j, '$.subagentInfo.parentComposerId') = ? AND coalesce(json_extract(j, '$.isBestOfNSubcomposer'), 0) = 0`,
+      )
+      .all(id) as Array<{ id: string; at: unknown }>
+  ).filter((c) => !ctx.seen.has(c.id))
+  const children: Session[] = []
+  const turns: Turn[] = []
+  const ids = new Set<string>()
+  const shown = modelResults(db, data?.conversationState)
+  const spawn = (upTo: number) => {
+    for (const c of spawned.filter((c) => (typeof c.at === "number" ? c.at : Number.POSITIVE_INFINITY) <= upTo && !ctx.seen.has(c.id))) {
+      if (ctx.depth >= 3) {
+        lost.add("nested subagents beyond depth 3")
+        ctx.seen.add(c.id)
+        continue
+      }
+      const child = readComposer(db, c.id, { ...ctx, depth: ctx.depth + 1 })
+      if (!child) continue
+      children.push(child.session)
+      turns.push({ kind: "subagent", sessionId: child.session.header.id, ...(child.session.header.title ? { description: child.session.header.title } : {}) })
+    }
+  }
+  spawn(0)
+  ordered.forEach(([bid, b], i) => {
+    turns.push(...bubbleTurns(b, bid, h, lost, ids, shown))
+    spawn(i + 1)
+  })
+  spawn(Number.POSITIVE_INFINITY)
+
+  if (!ordered.length) {
+    const t = ctx.transcripts.get(id)
+    if (t) {
+      turns.push(...transcriptTurns(t.file, id, lost))
+      h.sourcePath = t.file
+    } else if (Array.isArray(data?.conversation) && data!.conversation.length) lost.add("inline conversation (older composer format, not read)", data!.conversation.length)
+  }
+  if (!h.models.length) {
+    const m = str(data?.modelConfig?.modelName)
+    if (m && m !== "default") noteModel(h, m) // "default" is Cursor's placeholder, not a model
+  }
+  h.updatedAt ??= [...turns].reverse().find((t) => t.at)?.at ?? h.startedAt
+  h.startedAt ??= turns.find((t) => t.at)?.at
+
+  // Where it ran, cheapest first; the session's own branch and commit win over the folder's current ones.
+  const hash = head?.workspaceId ?? str(data?.workspaceIdentifier?.id)
+  let cwd = uriFolder(data?.workspaceIdentifier?.uri) ?? uriFolder(head?.uri) ?? ctx.ws.folder(hash)
+  for (const [, b] of ordered) cwd ??= bubbleFolder(b.workspaceProjectDir) ?? (Array.isArray(b.workspaceUris) ? bubbleFolder(b.workspaceUris[0]) : undefined)
+  if (!cwd && ctx.transcripts.has(id) && !ctx.ws.known(hash)) cwd = ctx.ws.bySlug(ctx.transcripts.get(id)!.slug)
+  h.project = {
+    ...(cwd ? { cwd } : {}),
+    ...(str(data?.gitWorktree?.branchName) ?? str(data?.createdOnBranch) ? { gitBranch: str(data?.gitWorktree?.branchName) ?? str(data?.createdOnBranch) } : {}),
+    ...(str(data?.gitWorktree?.commitHash) ? { gitCommit: str(data?.gitWorktree?.commitHash) } : {}),
+  }
+  lost.flush(h)
+  const session: Session = children.length ? { header: h, turns, children } : { header: h, turns }
+  return { session, scan: !cwd && !ctx.ws.known(hash) }
+}
+
+/** The project folder's git state under what the session itself recorded; children inherit the folder. */
+function settle(s: Session, cwd: string | undefined) {
+  const p = s.header.project
+  const dir = p.cwd ?? cwd
+  s.header.project = { ...(dir ? { cwd: dir } : {}), ...gitInfo(dir), ...(p.gitBranch ? { gitBranch: p.gitBranch } : {}), ...(p.gitCommit ? { gitCommit: p.gitCommit } : {}) }
+  for (const c of s.children ?? []) settle(c, dir)
+}
+
+async function read(ref: SessionRef, home: string): Promise<Session> {
+  const dbPath = globalDb(home)
+  const ws = workspaces(home)
+  const transcripts = transcriptIndex(home)
+  const ctx: Ctx = { dbPath, ws, transcripts, depth: 0, seen: new Set() }
+  let found = exists(dbPath) ? withSnapshot(dbPath, (db) => (hasTable(db, "cursorDiskKV") ? readComposer(db, ref.sourceId, ctx) : undefined)) : undefined
+  if (!found) {
+    const t = transcripts.get(ref.sourceId)
+    if (!t) throw new Error(`Cursor has no chat ${ref.sourceId} in ${dbPath} or ~/.cursor/projects`)
+    const lost = lossCounter()
+    const h = header(TOOL, ref.sourceId, { sourcePath: t.file, updatedAt: mtime(t.file) })
+    const turns = transcriptTurns(t.file, ref.sourceId, lost)
+    h.startedAt = turns.find((x) => x.at)?.at
+    lost.flush(h)
+    found = { session: { header: h, turns }, scan: true }
+  }
+  // The last resort for the folder: the workspace databases that list this composer (outside the snapshot).
+  let cwd = found.session.header.project.cwd ?? ref.cwd
+  if (!cwd && found.scan) cwd = ws.listing([ref.sourceId]).get(ref.sourceId)
+  settle(found.session, cwd)
+  return found.session
+}
+
+export const readers: Reader[] = [{ tool: TOOL, label: "Cursor", list, read }]
+export const writers: Writer[] = [cursorWriter]

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

@@ -0,0 +1,122 @@
+import { join } from "node:path"
+import type { Turn } from "../../session/types.ts"
+import { exists, isDir, ls, readJsonl } from "../../fsutil.ts"
+import { iso, type lossCounter, toolKindOf } from "../../session/util.ts"
+
+export type Loss = ReturnType<typeof lossCounter>
+
+// Cursor's readable agent transcripts, <home>/.cursor/projects/<slug>/agent-transcripts/<id>/<id>.jsonl,
+// written by both the IDE and the CLI. They keep text and tool calls but no tool results and no ids
+// (catalogue entry 23), so the IDE reader uses them only for a composer whose bubbles are gone.
+// Also here: the user-text cleanup both Cursor readers need, since Cursor wraps what the person typed in
+// harness tags (<timestamp>, <user_query>) and injects context (<user_info>, <rules>...) as user text.
+
+/** The project-folder slug Cursor uses under ~/.cursor/projects (cursor-agent 2026.10, utils/workspace-paths). */
+export function slugOf(folder: string): string {
+  return folder.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "")
+}
+
+/** Every primary transcript under `home`: composer id → { file, slug }. Directory listings only. */
+export function transcriptIndex(home: string): Map<string, { file: string; slug: string }> {
+  const out = new Map<string, { file: string; slug: string }>()
+  const root = join(home, ".cursor", "projects")
+  for (const slug of ls(root)) {
+    const dir = join(root, slug, "agent-transcripts")
+    if (!isDir(dir)) continue
+    for (const name of ls(dir)) {
+      // Current layout: <id>/<id>.jsonl; legacy layout: <id>.jsonl directly under agent-transcripts.
+      const nested = join(dir, name, `${name}.jsonl`)
+      if (exists(nested)) out.set(name, { file: nested, slug })
+      else if (name.endsWith(".jsonl") && !out.has(name.slice(0, -6))) out.set(name.slice(0, -6), { file: join(dir, name), slug })
+    }
+  }
+  return out
+}
+
+/**
+ * Ids of the Cursor CLI's chats and ACP sessions that have a store. The CLI writes its transcripts beside
+ * the IDE's, under the same ids, so these are the CLI reader's sessions, not orphaned IDE chats.
+ */
+export function cliChatIds(home: string): Set<string> {
+  const root = join(home, ".cursor")
+  const out = new Set<string>()
+  for (const bucket of ls(join(root, "chats"))) for (const id of ls(join(root, "chats", bucket))) if (exists(join(root, "chats", bucket, id, "store.db"))) out.add(id)
+  for (const id of ls(join(root, "acp-sessions"))) if (exists(join(root, "acp-sessions", id, "store.db"))) out.add(id)
+  return out
+}
+
+// Context blocks Cursor's harness puts into user messages (cursor-agent 2026.10, agent-transcript), which
+// are not what the person typed. Cursor's own transcript writer strips the same list.
+const CONTEXT_TAGS = [
+  "user_info", "project_layout", "rules", "always_applied_workspace_rules", "agent_requestable_workspace_rules", "user_rules",
+  "agent_skills", "available_skills", "cloud_instructions", "cloud_task_instructions", "open_and_recently_viewed_files",
+  "system_reminder", "system-reminder", "instructions_update", "mcp_instructions", "mcp_file_system", "mcp_file_system_servers",
+  "git_status", "agent_transcripts", "cursor_rules_context", "attached_files", "system_notification", "task_notification", "agent_notification",
+]
+const block = (tag: string) => new RegExp(`<${tag}(?:\\s[^>]*)?>[\\s\\S]*?</${tag}>`, "gi")
+const CONTEXT_RE = CONTEXT_TAGS.map(block)
+
+/**
+ * A <timestamp> value, "Sunday, November 8, 2026, 10:00 AM (GMT+5:30)", as ISO. The zone is in
+ * parentheses, which JavaScript's date parser ignores (it would read the time as the reader's local
+ * time), so the offset is applied here.
+ */
+export function stampTime(s: string): string | undefined {
+  const zone = s.match(/\((?:GMT|UTC)(?:\s*([+-])(\d{1,2})(?::?(\d{2}))?)?\)\s*$/)
+  const base = s.replace(/\s*\([^)]*\)\s*$/, "")
+  if (!zone) return iso(base) // no zone written: local time is the only reading left
+  const t = Date.parse(`${base} UTC`)
+  if (!Number.isFinite(t)) return undefined
+  const offset = (Number(zone[2] ?? 0) * 60 + Number(zone[3] ?? 0)) * (zone[1] === "-" ? -1 : 1)
+  return new Date(t - offset * 60_000).toISOString()
+}
+
+/**
+ * What the person typed, from a harness user message: the <user_query> blocks when there are any, else
+ * the text with injected context blocks removed. `at` comes from a <timestamp> block when present.
+ * `context` says the message was nothing but injected context.
+ */
+export function userText(raw: string): { text: string; at?: string; context: boolean } {
+  const stamp = raw.match(/<timestamp>([\s\S]*?)<\/timestamp>/)?.[1]?.trim()
+  const at = stamp ? stampTime(stamp) : undefined
+  const queries = [...raw.matchAll(/<user_query>([\s\S]*?)<\/user_query>/g)].map((m) => m[1]!.trim()).filter(Boolean)
+  if (queries.length) return { text: queries.join("\n\n"), at, context: false }
+  let text = raw
+  if (text.includes("<")) for (const re of [...CONTEXT_RE, block("timestamp")]) text = text.replace(re, "")
+  text = text.replace(/\n{3,}/g, "\n\n").trim()
+  return { text, at, context: !text && raw.trim().length > 0 }
+}
+
+/**
+ * Turns from a transcript file. Tool calls get ids made from the session id and their position, since
+ * the file has none; their results were never written, which is counted in `lost`.
+ */
+export function transcriptTurns(file: string, sessionId: string, lost: Loss): Turn[] {
+  const { rows, bad } = readJsonl(file)
+  const turns: Turn[] = []
+  let calls = 0
+  for (const r of rows) {
+    if (r.type === "turn_ended") continue // a turn boundary with a status, nothing said
+    const role = r.role
+    const content = r.message?.content
+    if ((role !== "user" && role !== "assistant") || (!Array.isArray(content) && typeof content !== "string")) {
+      lost.add(`unknown record types: ${String(r.type ?? role ?? "record")}`)
+      continue
+    }
+    const parts: Array<Record<string, any>> = typeof content === "string" ? [{ type: "text", text: content }] : content
+    for (const p of parts) {
+      if (p?.type === "text" && typeof p.text === "string") {
+        if (role === "user") {
+          const u = userText(p.text)
+          if (u.text) turns.push({ kind: "user", ...(u.at ? { at: u.at } : {}), text: u.text })
+          else if (u.context) lost.add("injected context messages")
+        } else if (p.text.trim()) turns.push({ kind: "assistant", text: p.text })
+      } else if (p?.type === "tool_use" && typeof p.name === "string") {
+        turns.push({ kind: "tool_call", id: `${sessionId}:t${++calls}`, name: p.name, toolKind: toolKindOf(p.name), input: p.input ?? {} })
+      } else lost.add(`unknown record types: ${String(p?.type ?? "part")}`)
+    }
+  }
+  if (calls) lost.add("tool results (agent-transcripts do not keep them)", calls)
+  if (bad) lost.add("unreadable transcript lines", bad)
+  return turns
+}