@100xprompt/brain 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,353 @@
+import { randomUUID } from "node:crypto"
+import { mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs"
+import { basename, join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, gitInfo, isDir, versionOf } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { countTurns, firstUserText, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { LABEL, TOOL, TESTED_EVENT_VERSION } from "./records.ts"
+import { reader } from "./reader.ts"
+
+// Continues a portable session in the Copilot CLI as a new session: ~/.copilot/session-state/<uuid>/ with
+// events.jsonl, workspace.yaml and checkpoints/index.md, which `copilot --resume <uuid>` opens.
+//
+// The records are the ones Copilot CLI 1.0.107 writes itself when it imports a session
+// (`copilot sessions import`, checked on a real run): session.start, then user.message, assistant.message
+// with toolRequests, one tool.execution_start per call and a tool.execution_complete per result, every
+// event on one parentId chain with uuid ids. Failed results carry error.message, as Copilot writes them.
+// Calls become Copilot's own tools (view, edit, create, bash, grep, glob) where their arguments fit.
+// Its own resume loads such a session offline (session.list and session.resume over the headless server).
+//
+// The note saying where the session came from is a user.message with source "system", the SDK's provenance
+// for internal application context, so it is not taken for the person's request. Readable reasoning stays
+// as assistant.reasoning events (timeline records; Copilot replays only its own opaque reasoning). The
+// session starts from the last compaction summary: Copilot's compaction events point at checkpoint files
+// and model-call metadata that cannot be made up for a summary written elsewhere.
+
+/** Copilot CLI versions whose session files this writer was checked against. */
+export const TESTED_VERSIONS = ["1.0.107"]
+
+/** The installed version ("GitHub Copilot CLI 1.0.107." → "1.0.107"), or undefined when it is missing. */
+export function copilotVersion(bin = "copilot"): string | undefined {
+  return versionOf(bin)?.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/)?.[1]
+}
+
+/** The marker on the note's user.message; readers skip it like any internal context. */
+export const NOTE_SOURCE = "system"
+
+const continuedNote = (label: string, id: string, when: string) =>
+  `[This session continues ${label} session ${id}, carried over by brain session on ${when}. The turns below are its history; reasoning and anything listed as lost did not carry over. Check files before relying on details, since they may have changed.]`
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+/** Copilot records the resolved folder (/private/tmp, not /tmp). */
+function realCwd(cwd: string): string {
+  try {
+    return realpathSync(cwd)
+  } catch {
+    return cwd
+  }
+}
+
+/** A YAML scalar Copilot's parser reads back as the same string. */
+const yamlString = (s: string) => JSON.stringify(s)
+
+type Call = Extract<Turn, { kind: "tool_call" }>
+type Result = Extract<Turn, { kind: "tool_result" }>
+
+// Argument names other tools use for the same thing.
+const FILE = ["file_path", "path", "filePath", "absolute_path", "target_file", "file", "filename"]
+const OLD = ["old_string", "oldString", "old_str", "old_text"]
+const NEW = ["new_string", "newString", "new_str", "new_text"]
+const CONTENT = ["content", "contents", "file_text", "text"]
+const COMMAND = ["command", "cmd", "commandLine"]
+const PATTERN = ["pattern", "regex", "query", "glob_pattern"]
+const DIR = ["path", "dir_path", "directory", "target_directory"]
+
+/**
+ * The call as Copilot CLI 1.0.107's own tool when its arguments fit one: view {path}, edit {path, old_str,
+ * new_str}, create {path, file_text}, bash {command}, grep / glob {pattern, paths}. Otherwise undefined, and
+ * the call keeps its own name and arguments.
+ */
+export function copilotTool(c: Call): { name: string; args: Record<string, unknown> } | undefined {
+  const input = c.input && typeof c.input === "object" && !Array.isArray(c.input) ? (c.input as Record<string, unknown>) : {}
+  const pick = (keys: string[]) => keys.map((k) => input[k]).find((v) => typeof v === "string" || (Array.isArray(v) && v.every((x) => typeof x === "string"))) as string | string[] | undefined
+  const str = (keys: string[]) => {
+    const v = pick(keys)
+    return Array.isArray(v) ? v.join(" ") : v
+  }
+  const path = str(FILE)
+  switch (c.toolKind) {
+    case "read":
+      return path ? { name: "view", args: { path } } : undefined
+    case "edit": {
+      const [o, n] = [str(OLD), str(NEW)]
+      return path && o !== undefined && n !== undefined ? { name: "edit", args: { path, old_str: o, new_str: n } } : undefined
+    }
+    case "write": {
+      const text = str(CONTENT)
+      return path && text !== undefined ? { name: "create", args: { path, file_text: text } } : undefined
+    }
+    case "shell": {
+      const command = str(COMMAND)
+      return command ? { name: "bash", args: { command } } : undefined
+    }
+    case "search": {
+      const pattern = str(PATTERN)
+      const dir = str(DIR)
+      if (!pattern) return undefined
+      return { name: /glob/i.test(c.name) ? "glob" : "grep", args: { pattern, ...(dir ? { paths: dir } : {}) } }
+    }
+    default:
+      return undefined
+  }
+}
+type Event = { type: string; data: Record<string, unknown>; id: string; timestamp: string; parentId: string | null }
+
+export interface EventsPlan {
+  events: Event[]
+  workspace: string
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+  title: string
+}
+
+/** The events and workspace.yaml of a new Copilot CLI session `sessionId` continuing `session`. Pure. */
+export function planEvents(session: Session, opts: { sessionId: string; cwd: string; version: string; now: Date; branch?: string; commit?: string }): EventsPlan {
+  const drops = new Map<string, number>()
+  const drop = (what: string, n = 1) => drops.set(what, (drops.get(what) ?? 0) + n)
+  const label = toolLabel(session.header.tool)
+
+  // Copilot has no way to replay a foreign compaction, so the session starts from the last summary.
+  let turns = session.turns
+  let lastCompaction = -1
+  turns.forEach((t, i) => {
+    if (t.kind === "compaction") lastCompaction = i
+  })
+  if (lastCompaction >= 0) {
+    const before = turns.slice(0, lastCompaction).filter((t) => t.kind !== "compaction").length
+    if (before) drop("turns before the last compaction (the summary stands in for them)", before)
+    turns = turns.slice(lastCompaction)
+  }
+
+  const events: Event[] = []
+  let clock = opts.now.getTime()
+  let parent: string | null = null
+  const push = (type: string, data: Record<string, unknown>) => {
+    const id = randomUUID()
+    events.push({ type, data, id, timestamp: new Date(clock++).toISOString(), parentId: parent })
+    parent = id
+  }
+  const startTime = opts.now.toISOString()
+  push("session.start", {
+    sessionId: opts.sessionId,
+    version: TESTED_EVENT_VERSION,
+    producer: "copilot-agent",
+    copilotVersion: opts.version,
+    startTime,
+    contextTier: null,
+    context: { cwd: opts.cwd, ...(opts.branch ? { branch: opts.branch } : {}), ...(opts.commit ? { headCommit: opts.commit } : {}) },
+    alreadyInUse: false,
+  })
+  push("user.message", { content: continuedNote(label, session.header.id, startTime.slice(0, 10)), source: NOTE_SOURCE })
+
+  const results = new Map<string, Result>()
+  const callIds = new Set<string>()
+  for (const t of turns) {
+    if (t.kind === "tool_result" && !results.has(t.callId)) results.set(t.callId, t)
+    if (t.kind === "tool_call") callIds.add(t.id)
+  }
+  // Call ids are Copilot's own uuids, mapped once so the call and its result agree.
+  const ids = new Map<string, string>()
+  const idFor = (id: string) => {
+    let v = ids.get(id)
+    if (!v) ids.set(id, (v = randomUUID()))
+    return v
+  }
+  const toolName = (name: string) => name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 64) || "tool"
+  const args = (input: unknown) => (input && typeof input === "object" && !Array.isArray(input) ? input : { input: input ?? null })
+  const nameOf = (c: Call) => copilotTool(c)?.name ?? toolName(c.name)
+  const argsOf = (c: Call) => copilotTool(c)?.args ?? args(c.input)
+
+  const expect = { users: 0, assistants: 0, calls: 0 }
+  // The assistant message being built: its text and calls, written once a result or a new message ends it.
+  let cur: { content: string; calls: Call[]; model?: string } | undefined
+  let reasoning: string[] = []
+  const answered = new Set<string>()
+  const flush = () => {
+    if (!cur) return
+    for (const text of reasoning) push("assistant.reasoning", { reasoningId: randomUUID(), content: text })
+    reasoning = []
+    // Copilot CLI 1.0.70 marks each request `type: "function"` and stamps the answering model on the message.
+    const toolRequests = cur.calls.map((c) => ({ name: nameOf(c), toolCallId: idFor(c.id), arguments: argsOf(c), type: "function" }))
+    push("assistant.message", { messageId: randomUUID(), ...(cur.model ? { model: cur.model } : {}), content: cur.content, ...(toolRequests.length ? { toolRequests } : {}) })
+    if (cur.content.trim()) expect.assistants++
+    for (const c of cur.calls) push("tool.execution_start", { toolCallId: idFor(c.id), toolName: nameOf(c), arguments: argsOf(c) })
+    // A call the session never answered is closed as a failure, so every request has its completion.
+    for (const c of cur.calls) {
+      if (results.has(c.id)) continue
+      push("tool.execution_complete", { toolCallId: idFor(c.id), success: false, error: { message: "No result was recorded for this call; the session moved on before it finished." } })
+      answered.add(c.id)
+      drop("tool calls without a result (closed as failures)")
+    }
+    cur = undefined
+  }
+
+  for (const t of turns) {
+    switch (t.kind) {
+      case "user": {
+        flush()
+        if (reasoning.length) drop("reasoning without a reply", reasoning.length)
+        reasoning = []
+        const attachments = (t.attachments ?? [])
+          .filter((a) => a.path)
+          .map((a) => ({ type: "file", path: a.path!, displayName: a.name ?? basename(a.path!), ...(a.mime ? { mimeType: a.mime } : {}) }))
+        if (!t.text.trim() && !attachments.length) break
+        push("user.message", { content: t.text, ...(attachments.length ? { attachments } : {}) })
+        expect.users++
+        break
+      }
+      case "assistant":
+        // Text after a tool call was written once the call's result came back: a new message.
+        if (cur?.calls.length) flush()
+        if (cur?.content.trim() && t.text.trim()) flush()
+        cur ??= { content: "", calls: [] }
+        cur.content = t.text
+        if (t.model) cur.model = t.model
+        break
+      case "tool_call":
+        if (ids.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        idFor(t.id)
+        cur ??= { content: "", calls: [] }
+        cur.calls.push(t)
+        expect.calls++
+        break
+      case "tool_result": {
+        if (!callIds.has(t.callId) || !ids.has(t.callId)) {
+          drop("tool results without a call")
+          break
+        }
+        if (answered.has(t.callId) || results.get(t.callId) !== t) {
+          drop("repeated tool results")
+          break
+        }
+        if (cur?.calls.some((c) => c.id === t.callId)) flush()
+        let output = t.output
+        if (t.fullPath) output += `\n\n[Full output: ${t.fullPath}]`
+        push(
+          "tool.execution_complete",
+          t.ok ? { toolCallId: idFor(t.callId), success: true, result: { content: output } } : { toolCallId: idFor(t.callId), success: false, error: { message: output || "The tool failed." } },
+        )
+        answered.add(t.callId)
+        break
+      }
+      case "reasoning":
+        if (cur?.calls.length) flush()
+        reasoning.push(t.text)
+        break
+      case "compaction":
+        flush()
+        push("user.message", { content: `[Summary of the earlier conversation in ${label}, which replaced the turns before it]\n\n${t.summary}`, source: NOTE_SOURCE })
+        break
+      case "file_edit":
+        if (!t.callId || !callIds.has(t.callId)) drop("file edits outside a tool call")
+        break
+      case "subagent":
+        drop("subagent transcripts (their results stay in the parent's tool results)")
+        break
+    }
+  }
+  flush()
+  if (reasoning.length) drop("reasoning without a reply", reasoning.length)
+
+  const title = `${session.header.title ?? firstUserText(session)?.replace(/\s+/g, " ").trim().slice(0, 60) ?? "Session"} (from ${label})`
+  const workspace = [
+    `id: ${opts.sessionId}`,
+    `cwd: ${yamlString(opts.cwd)}`,
+    "client_name: github/cli",
+    "last_client_name: github/cli",
+    `name: ${yamlString(title)}`,
+    "user_named: true",
+    "summary_count: 0",
+    "fork_count: 0",
+    `created_at: ${startTime}`,
+    `updated_at: ${new Date(clock).toISOString()}`,
+    "",
+  ].join("\n")
+  return { events, workspace, lost: [...drops].map(([what, n]) => `${what} (${n})`), expect, title }
+}
+
+const CHECKPOINT_INDEX = `# Checkpoint History
+
+Checkpoints are listed in chronological order. Checkpoint 1 is the oldest, higher numbers are more recent.
+
+| # | Title | File |
+|---|-------|------|
+`
+
+/** The Copilot CLI writer; `version` is for tests, which must not depend on an installed binary. */
+export function copilotCliWriter(opts: { version?: string } = {}): Writer {
+  const installed = () => opts.version ?? copilotVersion()
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed()
+      if (!v) return { ok: false, why: "the Copilot CLI is not installed (`copilot --version` did not run)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Copilot CLI ${v} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; Copilot resumes a session in its working directory` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const cwd = realCwd(w.cwd)
+      const git = gitInfo(cwd, w.home)
+      const root = join(w.home, ".copilot", "session-state")
+      let sessionId = randomUUID()
+      while (exists(join(root, sessionId)) || exists(join(root, `${sessionId}.jsonl`))) sessionId = randomUUID()
+      const dir = join(root, sessionId)
+      const plan = planEvents(session, { sessionId, cwd, version: installed() ?? TESTED_VERSIONS[TESTED_VERSIONS.length - 1]!, now: new Date(), branch: git.gitBranch, commit: git.gitCommit })
+      const paths = { events: join(dir, "events.jsonl"), workspace: join(dir, "workspace.yaml"), index: join(dir, "checkpoints", "index.md") }
+      if (!w.dryRun) {
+        // mkdir without recursive on the session folder itself: an existing session is never touched.
+        mkdirSync(root, { recursive: true })
+        mkdirSync(dir)
+        try {
+          mkdirSync(join(dir, "checkpoints"))
+          writeFileSync(paths.events, `${plan.events.map((e) => JSON.stringify(e)).join("\n")}\n`, { flag: "wx" })
+          writeFileSync(paths.workspace, plan.workspace, { flag: "wx" })
+          writeFileSync(paths.index, CHECKPOINT_INDEX, { flag: "wx" })
+          const back = await reader.read({ tool: TOOL, sourceId: sessionId, path: paths.events, extra: { dir } }, w.home)
+          const n = countTurns(back)
+          const pairs = unpaired(back)
+          if (n.user !== plan.expect.users || n.assistant !== plan.expect.assistants || n.tool_call !== plan.expect.calls || pairs.calls.length || pairs.results.length)
+            throw new Error(
+              `the new Copilot CLI session did not read back as written (users ${n.user}/${plan.expect.users}, replies ${n.assistant}/${plan.expect.assistants}, tool calls ${n.tool_call}/${plan.expect.calls}, unpaired ${pairs.calls.length + pairs.results.length}); nothing was kept`,
+            )
+          readFileSync(paths.workspace, "utf8")
+        } catch (e) {
+          rmSync(dir, { recursive: true, force: true })
+          throw e
+        }
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId,
+        written: [paths.events, paths.workspace, paths.index],
+        open: `cd ${shellQuote(cwd)} && copilot --resume ${sessionId}`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const copilotCliNativeWriter = copilotCliWriter()

package/src/adapters/crush/index.ts

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { crushReader } from "./reader.ts"
+import { crushWriter } from "./writer.ts"
+
+// Charm's Crush: reads every project's .crush/crush.db listed in projects.json, and continues any session as
+// a new native session in the project's store (with Crush closed, after a backup).
+export const readers: Reader[] = [crushReader]
+export const writers: Writer[] = [crushWriter]

package/src/adapters/crush/reader.ts

@@ -0,0 +1,180 @@
+import type { Database } from "bun:sqlite"
+import { join } from "node:path"
+import { exists, gitInfo, readJson } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import { keepImage } from "../../session/attachments.ts"
+import type { Attachment, Session, Turn } from "../../session/types.ts"
+import { clip, header, iso, lossCounter, noteModel, toolKindOf } from "../../session/util.ts"
+import { CONTINUED_NOTE } from "../opencode/note.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { LABEL, TOOL, projectsFile } from "./records.ts"
+
+// Reads Crush sessions from every project store listed in projects.json (records.ts). Each store is read from
+// a copy, as Crush keeps it in WAL mode. Subagent sessions are the store's sessions whose parent is this one
+// (their id is the agent tool call's id); the "title-<id>" sessions Crush uses to name a session are skipped.
+
+/** The stores Crush has registered: one per project folder it ran in. */
+function stores(home: string): Array<{ cwd: string; db: string }> {
+  const list = readJson<{ projects?: Array<{ path?: string; data_dir?: string }> }>(projectsFile(home))?.projects ?? []
+  const seen = new Set<string>()
+  const out: Array<{ cwd: string; db: string }> = []
+  for (const p of list) {
+    if (typeof p.path !== "string" || typeof p.data_dir !== "string") continue
+    const db = join(p.data_dir, "crush.db")
+    if (seen.has(db) || !exists(db)) continue
+    seen.add(db)
+    out.push({ cwd: p.path, db })
+  }
+  return out
+}
+
+export const crushReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+  async list(home) {
+    const refs: SessionRef[] = []
+    for (const { cwd, db } of stores(home)) {
+      try {
+        const rows = withSnapshot(db, (d) => d.query("SELECT id, title, updated_at FROM sessions WHERE parent_session_id IS NULL").all()) as Array<Record<string, any>>
+        for (const r of rows)
+          refs.push({
+            tool: TOOL,
+            sourceId: String(r.id),
+            path: db,
+            ...(r.title ? { title: String(r.title) } : {}),
+            cwd,
+            ...(iso(r.updated_at) ? { updatedAt: iso(r.updated_at)! } : {}),
+          })
+      } catch {
+        // A store that cannot be copied or opened lists nothing; read() says why for a session in it.
+      }
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+  async read(ref) {
+    if (!exists(ref.path)) throw new Error(`Crush store not found: ${ref.path}`)
+    return withSnapshot(ref.path, (d) => readCrush(d, ref.sourceId, { path: ref.path, ...(ref.cwd ? { cwd: ref.cwd } : {}) }))
+  },
+}
+
+const json = (s: unknown): any => {
+  try {
+    return JSON.parse(String(s))
+  } catch {
+    return undefined
+  }
+}
+
+/** One session from an open Crush store, with its subagent sessions two levels down. */
+export function readCrush(d: Database, id: string, where: { path: string; cwd?: string }, depth = 0): Session {
+  const row = d.query("SELECT * FROM sessions WHERE id = ?").get(id) as Record<string, any> | null
+  if (!row) throw new Error(`session ${id} not found`)
+  const cwd = where.cwd
+  const h = header(TOOL, id, {
+    sourcePath: where.path,
+    ...(row.title ? { title: String(row.title) } : {}),
+    project: { ...(cwd ? { cwd } : {}), ...gitInfo(cwd) },
+    ...(iso(row.created_at) ? { startedAt: iso(row.created_at)! } : {}),
+    ...(iso(row.updated_at) ? { updatedAt: iso(row.updated_at)! } : {}),
+    ...(row.parent_session_id ? { parent: { id: `${TOOL}:${row.parent_session_id}`, kind: "subagent" as const } } : {}),
+  })
+  const lost = lossCounter()
+  const turns: Turn[] = []
+  const callIds = new Set<string>()
+  const children = new Set(
+    (d.query("SELECT id FROM sessions WHERE parent_session_id = ? AND id NOT LIKE 'title-%'").all(id) as Array<{ id: string }>).map((r) => r.id),
+  )
+  // created_at has one-second resolution; Crush writes a session's messages in order, so rowid breaks ties.
+  for (const m of d.query("SELECT rowid, * FROM messages WHERE session_id = ? ORDER BY created_at, rowid").all(id) as Array<Record<string, any>>) {
+    const parts = json(m.parts)
+    if (!Array.isArray(parts)) {
+      lost.add("unreadable messages")
+      continue
+    }
+    const at = iso(m.created_at)
+    const of = (type: string) => parts.filter((p: any) => p?.type === type).map((p: any) => (p.data ?? {}) as Record<string, any>)
+    if (m.role === "user") {
+      const texts = of("text")
+      if (texts.some((t) => t.hidden)) {
+        // A continuation Crush (or brain) added for the model only; brain's says where the session came from.
+        const continued = String(texts[0]?.text ?? "").match(CONTINUED_NOTE)?.[1]
+        if (continued) h.parent ??= { id: continued, kind: "continued" }
+        else lost.add("messages the tool injected as the user")
+        continue
+      }
+      for (const sc of of("shell_command")) {
+        const callId = `shell-${m.id}-${callIds.size}`
+        callIds.add(callId)
+        turns.push({ kind: "tool_call", ...(at ? { at } : {}), id: callId, name: "bash", toolKind: "shell", input: { command: sc.command } })
+        turns.push({ kind: "tool_result", callId, ok: !sc.exit_code, output: clip(String(sc.output ?? "")).text })
+      }
+      if (of("sub_agent_report").length) lost.add("subagent reports", of("sub_agent_report").length)
+      const attachments: Attachment[] = [
+        ...of("binary").map((b) => {
+          const mime = String(b.MIMEType ?? "")
+          const kept = mime.startsWith("image/") && typeof b.Data === "string" ? keepImage(b.Data, mime) : undefined
+          if (kept) return kept
+          return { kind: (mime.startsWith("image/") ? "image" : "file") as Attachment["kind"], ...(b.Path ? { path: String(b.Path) } : {}), ...(b.MIMEType ? { mime } : {}) }
+        }),
+        ...of("image_url").map(() => ({ kind: "image" as const })),
+      ]
+      if (of("image_url").length) lost.add("attachment data", of("image_url").length)
+      const text = texts.map((t) => String(t.text ?? "")).join("\n\n")
+      if (text.trim() || attachments.length) turns.push({ kind: "user", ...(at ? { at } : {}), text, ...(attachments.length ? { attachments } : {}) })
+      continue
+    }
+    if (m.role === "tool") {
+      for (const r of of("tool_result")) {
+        const callId = String(r.tool_call_id ?? "")
+        if (r.data) lost.add("images in tool results")
+        const out = clip(String(r.content ?? ""))
+        turns.push({ kind: "tool_result", ...(at ? { at } : {}), callId, ok: !r.is_error, output: out.text, ...(out.truncated ? { truncated: true } : {}) })
+      }
+      continue
+    }
+    if (m.role !== "assistant") {
+      lost.add(`unknown message roles: ${String(m.role)}`)
+      continue
+    }
+    const text = of("text").map((t) => String(t.text ?? "")).join("\n\n")
+    if (m.is_summary_message) {
+      if (text.trim()) turns.push({ kind: "compaction", ...(at ? { at } : {}), summary: text })
+      continue
+    }
+    const model = m.model ? String(m.model) : undefined
+    if (model && (text.trim() || of("tool_call").length)) noteModel(h, model)
+    for (const r of of("reasoning")) {
+      const signed = !!(r.signature || r.thought_signature || r.responses_data)
+      if (typeof r.thinking === "string" && r.thinking.trim()) {
+        turns.push({ kind: "reasoning", ...(at ? { at } : {}), text: r.thinking })
+        if (signed) lost.add("reasoning signatures")
+      } else if (signed) lost.add("signed reasoning")
+    }
+    if (text.trim()) turns.push({ kind: "assistant", ...(at ? { at } : {}), text, ...(model ? { model } : {}) })
+    for (const c of of("tool_call")) {
+      const name = String(c.name ?? "unknown")
+      let callId = String(c.id ?? "")
+      for (let n = 2; !callId || callIds.has(callId); n++) callId = `${String(c.id ?? "call")}#${n}`
+      callIds.add(callId)
+      const input = json(c.input) ?? c.input ?? {}
+      turns.push({ kind: "tool_call", ...(at ? { at } : {}), id: callId, name, toolKind: toolKindOf(name), input })
+      if (children.has(String(c.id))) turns.push({ kind: "subagent", ...(at ? { at } : {}), sessionId: `${TOOL}:${c.id}`, callId })
+    }
+    const finish = of("finish")[0]
+    if (finish && (finish.reason === "error" || finish.reason === "content_filter")) lost.add("error notices on replies")
+  }
+  lost.flush(h)
+  const s: Session = { header: h, turns }
+  if (depth < 2 && children.size) {
+    const kids: Session[] = []
+    for (const child of children) {
+      try {
+        kids.push(readCrush(d, child, where, depth + 1))
+      } catch {
+        h.lost.push(`unreadable subagent session (${child})`)
+      }
+    }
+    if (kids.length) s.children = kids
+  }
+  return s
+}