@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/aider/writer.ts

@@ -0,0 +1,269 @@
+import { closeSync, ftruncateSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { runId } from "./reader.ts"
+import {
+  HISTORY_FILE,
+  INPUT_HISTORY_FILE,
+  LABEL,
+  SUMMARY_PREFIX,
+  TESTED_VERSIONS,
+  TOOL,
+  aiderVersion,
+  assistantText,
+  continuedNote,
+  escapeLine,
+  historyRoot,
+  parseRuns,
+  pyLines,
+  userText,
+} from "./records.ts"
+
+// Continues a portable session in Aider as a new run appended to the project's chat history
+// (.aider.chat.history.md at the git root, else the folder), written the way Aider's InputOutput writes
+// one: the "# aider chat started at" line, each request as "#### " lines ending in a Markdown line break,
+// each reply as plain text between blank lines. `aider --restore-chat-history` then gives the model the
+// whole file as messages (utils.split_chat_history_markdown), this run included.
+//
+// Why append, not a fresh file with the old one backed up: Aider treats the file as the project's one
+// history. Every launch appends to it and --restore-chat-history replays all of it, so a continued session
+// is one more launch in that history; moving the existing file aside would hide the person's earlier Aider
+// work from Aider, which is modifying another session. Appending leaves every earlier byte as it was, and a
+// run that does not read back is cut off again at the length the file had before.
+//
+// Aider has no record for tool calls or reasoning. Tool calls and their results travel as text inside the
+// reply they belong to (that is what the model would see in an Aider chat anyway: edits and commands live in
+// the reply's text), reasoning is dropped. Lines the parser would misread ("# ", "#### ", "> " at the start
+// of a reply line) get one leading space, which Markdown ignores. A compaction is written the way Aider's
+// own summariser hands one to the model: a user message starting "I spoke to you previously about a number
+// of things." followed by the turns after it. The prompts also go into .aider.input.history, so the arrow
+// keys recall them as they would in Aider.
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+const pad = (n: number, w = 2) => String(n).padStart(w, "0")
+/** Local time as Python's datetime.now().strftime("%Y-%m-%d %H:%M:%S"). */
+const localStamp = (d: Date) => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`
+/** Local time as str(datetime.now()), which prompt_toolkit's FileHistory writes before each entry. */
+const pyNow = (d: Date) => `${localStamp(d)}.${pad(d.getMilliseconds(), 3)}000`
+
+/** A fence longer than any run of backticks in the text, so the text cannot close it. */
+const fence = (text: string) => "`".repeat(Math.max(3, ...[...text.matchAll(/`+/g)].map((m) => m[0].length + 1)))
+const fenced = (text: string, lang = "") => {
+  const f = fence(text)
+  return `${f}${lang}\n${text.replace(/\n+$/, "")}\n${f}`
+}
+
+/** Text with every line break Aider's parser knows as "\n", so what is written is what reads back. */
+const oneBreak = (text: string) => pyLines(text).join("\n")
+
+type Call = Extract<Turn, { kind: "tool_call" }>
+type Result = Extract<Turn, { kind: "tool_result" }>
+
+/** A tool call and its result as reply text. */
+function callText(call: Call, result: Result | undefined): string {
+  const input = typeof call.input === "string" ? call.input : JSON.stringify(call.input ?? {}, null, 2)
+  const parts = [`[Tool call: ${call.name} (${call.toolKind})]`, fenced(input, typeof call.input === "string" ? "" : "json")]
+  if (!result) parts.push("[No result was recorded for this call.]")
+  else {
+    let out = result.output || "(no output)"
+    if (result.fullPath) out += `\n\n[Full output: ${result.fullPath}]`
+    parts.push(result.ok ? "[Result]" : "[Result: failed]", fenced(out))
+  }
+  return parts.join("\n")
+}
+
+export interface MdPlan {
+  /** The run's text, appended to the history file as it stands. */
+  history: string
+  /** The prompts, in prompt_toolkit FileHistory form, appended to the input history. */
+  input: string
+  /** The messages Aider's parser must find in the run, for the read-back. */
+  messages: Array<{ role: "user" | "assistant"; text: string }>
+  lost: string[]
+}
+
+/** The run that continues `session` in Aider. Pure. */
+export function planRun(session: Session, now: Date): MdPlan {
+  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)
+
+  // From the last compaction on: Aider keeps no compaction in its file, it hands the model the summary instead.
+  let start = 0
+  let summary: string | undefined
+  session.turns.forEach((t, i) => {
+    if (t.kind === "compaction") {
+      start = i + 1
+      summary = t.summary
+    }
+  })
+  const before = session.turns.slice(0, start).filter((t) => t.kind !== "compaction").length
+  if (before) drop("turns before the last compaction, replaced by its summary", before)
+
+  const results = new Map<string, Result>()
+  for (const t of session.turns) if (t.kind === "tool_result" && !results.has(t.callId)) results.set(t.callId, t)
+  const callIds = new Set(session.turns.filter((t) => t.kind === "tool_call").map((t) => (t as Call).id))
+
+  const messages: MdPlan["messages"] = []
+  const prompts: string[] = []
+  let reply: string[] = []
+  const flush = () => {
+    const text = oneBreak(reply.join("\n\n")).trim()
+    if (text) messages.push({ role: "assistant", text })
+    reply = []
+  }
+  const user = (text: string, prompt: boolean) => {
+    flush()
+    messages.push({ role: "user", text: oneBreak(text) })
+    if (prompt) prompts.push(oneBreak(text))
+  }
+
+  user(continuedNote(label, session.header.id, now.toISOString().slice(0, 10)), false)
+  if (summary) user(`${SUMMARY_PREFIX}${summary}`, false)
+  const seen = new Set<string>()
+  for (const t of session.turns.slice(start)) {
+    switch (t.kind) {
+      case "user":
+        if (t.attachments?.length) drop("attachments (Aider's history holds text only)", t.attachments.length)
+        if (t.text.trim()) user(t.text, true)
+        break
+      case "assistant":
+        if (t.text.trim()) reply.push(t.text.trim())
+        break
+      case "tool_call":
+        if (seen.has(t.id)) break
+        seen.add(t.id)
+        reply.push(callText(t, results.get(t.id)))
+        drop("tool calls, kept as text in the replies (Aider has no tool-call record)")
+        if (!results.has(t.id)) drop("tool calls without a result")
+        break
+      case "tool_result":
+        if (!callIds.has(t.callId)) drop("tool results without a call")
+        break
+      case "file_edit":
+        if (t.callId && callIds.has(t.callId)) break
+        reply.push([`[Edited ${t.path}]`, ...(t.patch ? [fenced(t.patch, "diff")] : [])].join("\n"))
+        drop("file edits outside a tool call, kept as text")
+        break
+      case "reasoning":
+        drop("reasoning (Aider's history has no place for it)")
+        break
+      case "subagent":
+        drop("subagent sessions")
+        break
+      case "compaction":
+        break
+    }
+  }
+  flush()
+
+  // As InputOutput writes them: user_input() and ai_output() through append_chat_history().
+  const lines = [`\n# aider chat started at ${localStamp(now)}\n\n`]
+  for (const m of messages) {
+    if (m.role === "user") {
+      const body = pyLines(m.text).join("  \n#### ").replace(/\s+$/, "")
+      lines.push(`\n#### ${body}  \n`)
+    } else {
+      lines.push(`\n${pyLines(m.text).map(escapeLine).join("\n")}\n\n`)
+    }
+  }
+  const input = prompts.map((p) => `\n# ${pyNow(now)}\n${p.split("\n").map((l) => `+${l}\n`).join("")}`).join("")
+  return { history: lines.join(""), input, messages, lost: [...drops].map(([what, n]) => `${what} (${n})`) }
+}
+
+/** Appends `text` to `path` and returns how long the file was before, so a failed run can be cut off again. */
+function append(path: string, text: string): number {
+  const size = exists(path) ? statSync(path).size : -1
+  const fd = openSync(path, "a")
+  try {
+    writeSync(fd, text)
+  } finally {
+    closeSync(fd)
+  }
+  return size
+}
+
+/** Puts a file back to the length it had (or removes it when it did not exist). */
+function restore(path: string, size: number) {
+  if (size < 0) return rmSync(path, { force: true })
+  const fd = openSync(path, "r+")
+  try {
+    ftruncateSync(fd, size)
+  } finally {
+    closeSync(fd)
+  }
+}
+
+/**
+ * Whether an Aider is running: its command line runs the `aider` script (a pip install runs it through Python,
+ * so the process name is not "aider"). A running Aider appends its own lines to the history it has open, and
+ * lines it wrote after the continued run would read as part of it.
+ */
+function aiderRunning(): boolean {
+  try {
+    return Bun.spawnSync(["pgrep", "-f", "(^|/)aider( |$)"], { stdout: "pipe", stderr: "pipe" }).exitCode === 0
+  } catch {
+    return false
+  }
+}
+
+/** The Aider writer; `version` and `running` are for tests, which must not depend on an installed Aider. */
+export function aiderWriter(opts: { version?: string; running?: () => boolean } = {}): Writer {
+  const installed = () => opts.version ?? aiderVersion()
+  const running = opts.running ?? aiderRunning
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed()
+      if (!v) return { ok: false, why: "Aider is not installed (`aider --version` did not run)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Aider ${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; Aider keeps its history in the project` }
+      if (running()) return { ok: false, why: "Aider is running; quit it first, or its next lines would land inside the continued session's history" }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const cwd = resolve(w.cwd)
+      const root = historyRoot(cwd)
+      const historyPath = join(root, HISTORY_FILE)
+      const inputPath = join(root, INPUT_HISTORY_FILE)
+      const plan = planRun(session, new Date())
+      let sessionId: string | undefined
+      if (!w.dryRun) {
+        mkdirSync(root, { recursive: true })
+        const historySize = append(historyPath, plan.history)
+        // Read back as Aider will: the last run must hold exactly the messages planned.
+        const runs = parseRuns(readFileSync(historyPath, "utf8"))
+        const got = (runs[runs.length - 1]?.messages ?? []).filter((m) => m.role !== "tool")
+        const same =
+          got.length === plan.messages.length &&
+          got.every((m, i) => m.role === plan.messages[i]!.role && (m.role === "user" ? userText(m.content) : assistantText(m.content)).trim() === plan.messages[i]!.text.trim())
+        if (!same) {
+          restore(historyPath, historySize)
+          throw new Error(`the Aider history did not read back as written (${got.length} of ${plan.messages.length} messages); the file was put back as it was`)
+        }
+        if (plan.input) append(inputPath, plan.input)
+        const run = runs[runs.length - 1]!
+        sessionId = runId(historyPath, run, runs)
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        ...(sessionId ? { sessionId } : {}),
+        written: plan.input ? [historyPath, inputPath] : [historyPath],
+        open: `cd ${shellQuote(cwd)} && aider --restore-chat-history`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const aiderNativeWriter = aiderWriter()

package/src/adapters/amazon-q-cli/index.ts

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { amazonQCliReader } from "./reader.ts"
+import { amazonQCliNativeWriter } from "./writer.ts"
+
+// Amazon Q Developer CLI (`q chat`, superseded by Kiro CLI): reads the per-folder conversations in
+// data.sqlite3 and continues any session as the folder's conversation, which `q chat --resume` restores.
+export const readers: Reader[] = [amazonQCliReader]
+export const writers: Writer[] = [amazonQCliNativeWriter]

package/src/adapters/amazon-q-cli/reader.ts

@@ -0,0 +1,84 @@
+import type { Database } from "bun:sqlite"
+import { exists, gitInfo } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import type { Session } from "../../session/types.ts"
+import { header, iso } from "../../session/util.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { type ConversationState, LABEL, TOOL, dbPath, turnsOf } from "./records.ts"
+
+// Amazon Q CLI: one conversation per folder in data.sqlite3's `conversations` table, read from a copy with its
+// write-ahead log. Only conversations with history are listed: those are the ones `q chat --resume` restores.
+
+const firstPrompt = (s: ConversationState) => {
+  for (const e of s.history ?? []) {
+    const c = e.user?.content as Record<string, any> | undefined
+    const p = c?.Prompt?.prompt ?? c?.CancelledToolUses?.prompt
+    if (typeof p === "string" && p.trim()) return p.replace(/\s+/g, " ").trim().slice(0, 80)
+  }
+  return undefined
+}
+
+const lastTime = (s: ConversationState) => {
+  for (let i = (s.history?.length ?? 0) - 1; i >= 0; i--) {
+    const t = iso(s.history[i]!.user?.timestamp)
+    if (t) return t
+  }
+  return undefined
+}
+
+function rows(d: Database): Array<{ key: string; state: ConversationState }> {
+  const out: Array<{ key: string; state: ConversationState }> = []
+  for (const r of d.query("SELECT key, value FROM conversations").all() as Array<{ key: string; value: string }>) {
+    try {
+      const state = JSON.parse(r.value) as ConversationState
+      if (Array.isArray(state.history) && state.history.length) out.push({ key: r.key, state })
+    } catch {}
+  }
+  return out
+}
+
+/** The conversation stored for `key`, as a portable session. */
+export function readQ(d: Database, path: string, key: string, home: string): Session {
+  const r = d.query("SELECT value FROM conversations WHERE key = ?").get(key) as { value: string } | null
+  if (!r) throw new Error(`no Amazon Q conversation for ${key} in ${path}`)
+  const state = JSON.parse(r.value) as ConversationState
+  const title = firstPrompt(state)
+  const h = header(TOOL, String(state.conversation_id), {
+    sourcePath: path,
+    ...(title ? { title } : {}),
+    project: { cwd: key, ...gitInfo(key, home) },
+  })
+  const { turns, continued } = turnsOf(state, h)
+  if (continued) h.parent = { id: continued, kind: "continued" }
+  const times = turns.map((t) => t.at).filter((t): t is string => !!t)
+  if (times[0]) h.startedAt = times[0]
+  const last = lastTime(state)
+  if (last) h.updatedAt = last
+  return { header: h, turns }
+}
+
+export const amazonQCliReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+  async list(home) {
+    const db = dbPath(home)
+    if (!exists(db)) return []
+    try {
+      return withSnapshot(db, (d) =>
+        rows(d).map(({ key, state }): SessionRef => {
+          const title = firstPrompt(state)
+          const updatedAt = lastTime(state)
+          return { tool: TOOL, sourceId: String(state.conversation_id), path: db, cwd: key, ...(title ? { title } : {}), ...(updatedAt ? { updatedAt } : {}), extra: { key } }
+        }),
+      ).sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+    } catch {
+      return []
+    }
+  },
+  async read(ref, home) {
+    if (!exists(ref.path)) throw new Error(`Amazon Q database not found: ${ref.path}`)
+    const key = typeof ref.extra?.key === "string" ? ref.extra.key : ref.cwd
+    if (!key) throw new Error("this Amazon Q session reference names no folder")
+    return withSnapshot(ref.path, (d) => readQ(d, ref.path, key, home))
+  },
+}

package/src/adapters/amazon-q-cli/records.ts

@@ -0,0 +1,191 @@
+import { join } from "node:path"
+import { appSupport, versionOf } from "../../fsutil.ts"
+import type { Session, ToolKind, Turn } from "../../session/types.ts"
+import { asText, clip, iso, lossCounter, noteModel, toolKindOf } from "../../session/util.ts"
+import { CONTINUED_NOTE } from "../claude-code/records.ts"
+
+// What the Amazon Q Developer CLI keeps, shared by the reader and the writer. Checked against the source of
+// aws/amazon-q-developer-cli at 1.19.7 (crates/chat-cli: database/mod.rs and sqlite_migrations/,
+// cli/chat/conversation.rs, message.rs, parser.rs, context.rs, tools/, and the resume path in cli/chat/mod.rs).
+// Catalogue: docs/sessions/2026-11-08-session-formats.md, "Amazon Q Developer CLI".
+//
+// Q keeps one conversation per folder: a row of the `conversations` table in
+// ~/Library/Application Support/amazon-q/data.sqlite3 whose key is the folder's absolute path and whose value
+// is the ConversationState as serde_json writes it. `q chat --resume` loads the row for the folder it runs
+// in, and only when its history is not empty. The history is a list of entries, each one user message and
+// the assistant's reply to it; tool calls are the reply's tool_uses, answered by the next entry's user
+// message, which carries the results instead of a prompt.
+
+export const TOOL = "amazon-q-cli"
+export const LABEL = "Amazon Q CLI"
+
+/** Q CLI versions whose conversation JSON the writer was checked against (from source). */
+export const TESTED_VERSIONS = ["1.19.7"]
+
+export const dbPath = (home: string) => join(appSupport(home), "amazon-q", "data.sqlite3")
+
+/** "1.19.7" from `qchat --version` ("qchat 1.19.7") or `q --version`; undefined when neither runs. */
+export const qVersion = (bins = ["qchat", "q"]) => {
+  for (const b of bins) {
+    const v = versionOf(b)?.match(/\d+\.\d+\.\d+/)?.[0]
+    if (v) return v
+  }
+  return undefined
+}
+
+/** The default agent, whose context manager a new conversation gets (Agent::default, ContextManager::from_agent). */
+export const DEFAULT_AGENT = "q_cli_default"
+export const DEFAULT_CONTEXT_PATHS = ["AmazonQ.md", "AGENTS.md", "README.md", ".amazonq/rules/**/*.md"]
+/** calc_max_context_files_size with no model chosen: 75% of the default 200,000-token window. */
+export const DEFAULT_CONTEXT_FILES_SIZE = 150_000
+
+/** Q's reply placeholder for a user message that has none: every history entry needs one. */
+export const NO_REPLY = "[No reply was recorded for this message before the session moved to Amazon Q.]"
+
+export type ToolUseResultBlock = { Text: string } | { Json: unknown }
+export interface ToolUseResult {
+  tool_use_id: string
+  content: ToolUseResultBlock[]
+  status: "Success" | "Error"
+}
+export type UserContent =
+  | { Prompt: { prompt: string } }
+  | { CancelledToolUses: { prompt: string | null; tool_use_results: ToolUseResult[] } }
+  | { ToolUseResults: { tool_use_results: ToolUseResult[] } }
+export interface UserMessage {
+  additional_context: string
+  env_context: { env_state: { operating_system: string | null; current_working_directory: string | null; environment_variables: unknown[] } | null }
+  content: UserContent
+  timestamp: string | null
+  images: Array<{ format: string; source: { Bytes: number[] } }> | null
+}
+export interface AssistantToolUse {
+  id: string
+  name: string
+  orig_name: string
+  args: unknown
+  orig_args: unknown
+}
+export type AssistantMessage = { Response: { message_id: string | null; content: string } } | { ToolUse: { message_id: string | null; content: string; tool_uses: AssistantToolUse[] } }
+export interface HistoryEntry {
+  user: UserMessage
+  assistant: AssistantMessage
+  request_metadata: unknown
+}
+/** ConversationState as serialized; fields this adapter does not use are left loose. */
+export interface ConversationState {
+  conversation_id: string
+  next_message: UserMessage | null
+  history: HistoryEntry[]
+  valid_history_range: [number, number]
+  transcript: string[]
+  tools: Record<string, unknown>
+  context_manager: unknown
+  context_message_length: number | null
+  latest_summary: [string, unknown] | null
+  model?: string | null
+  model_info?: { model_id?: string } | null
+  file_line_tracker?: Record<string, unknown>
+  checkpoint_manager: unknown
+  mcp_enabled?: boolean
+  [k: string]: unknown
+}
+
+/** What a Q tool does. Its built-ins are fs_read (with operations), fs_write (with a command), execute_bash. */
+export function qToolKind(name: string, args: unknown): ToolKind {
+  const a = (args && typeof args === "object" ? args : {}) as Record<string, any>
+  if (name === "fs_read") {
+    const mode = Array.isArray(a.operations) ? a.operations[0]?.mode : a.mode
+    return mode === "Directory" ? "list" : mode === "Search" ? "search" : "read"
+  }
+  if (name === "fs_write") return a.command === "create" ? "write" : "edit"
+  if (name === "execute_bash" || name === "execute_cmd") return "shell"
+  if (name === "use_aws") return "shell"
+  if (name === "todo_list") return "todo"
+  if (name === "delegate") return "task"
+  return toolKindOf(name)
+}
+
+const str = (v: unknown) => (typeof v === "string" ? v : undefined)
+
+/** A call as Q's own built-in tool would have been called, when its arguments say what that tool needs. */
+export function qCall(c: Extract<Turn, { kind: "tool_call" }>): { name: string; args: Record<string, unknown> } | undefined {
+  const i = (c.input && typeof c.input === "object" && !Array.isArray(c.input) ? c.input : {}) as Record<string, unknown>
+  const path = str(i.file_path) ?? str(i.path) ?? str(i.filePath) ?? str(i.target_file) ?? str(i.absolute_path)
+  switch (c.toolKind) {
+    case "shell": {
+      const command = str(i.command) ?? str(i.cmd) ?? (Array.isArray(i.command) ? (i.command as unknown[]).map(String).join(" ") : undefined)
+      return command ? { name: "execute_bash", args: { command } } : undefined
+    }
+    case "write": {
+      const text = str(i.content) ?? str(i.file_text) ?? str(i.contents) ?? str(i.text)
+      return path && text !== undefined ? { name: "fs_write", args: { command: "create", path, file_text: text } } : undefined
+    }
+    case "edit": {
+      const before = str(i.old_string) ?? str(i.old_str) ?? str(i.oldText) ?? str(i.oldStr)
+      const after = str(i.new_string) ?? str(i.new_str) ?? str(i.newText) ?? str(i.newStr)
+      return path && before !== undefined && after !== undefined ? { name: "fs_write", args: { command: "str_replace", path, old_str: before, new_str: after } } : undefined
+    }
+    case "read":
+      return path ? { name: "fs_read", args: { operations: [{ mode: "Line", path }] } } : undefined
+    case "list":
+      return path ? { name: "fs_read", args: { operations: [{ mode: "Directory", path }] } } : undefined
+  }
+  return undefined
+}
+
+const blockText = (b: ToolUseResultBlock) => ("Text" in b ? b.Text : asText(b.Json))
+
+/**
+ * The portable turns of a Q conversation: the summary of a compaction first (Q keeps only the summary of the
+ * turns it replaced), then the history. Returns the id of the session a brain-written conversation continues,
+ * when its note is there.
+ */
+export function turnsOf(state: ConversationState, h: Session["header"]): { turns: Turn[]; continued?: string } {
+  const turns: Turn[] = []
+  const lost = lossCounter()
+  let continued: string | undefined
+  const model = state.model_info?.model_id ?? state.model ?? undefined
+  noteModel(h, model ?? undefined)
+  if (Array.isArray(state.latest_summary) && typeof state.latest_summary[0] === "string" && state.latest_summary[0].trim())
+    turns.push({ kind: "compaction", summary: state.latest_summary[0] })
+  const results = (rs: ToolUseResult[], at?: string) => {
+    for (const r of rs) {
+      const c = clip((r.content ?? []).map(blockText).join("\n"))
+      turns.push({ kind: "tool_result", ...(at ? { at } : {}), callId: String(r.tool_use_id), ok: r.status !== "Error", output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+    }
+  }
+  const prompt = (text: string | null | undefined, at?: string) => {
+    if (!text?.trim()) return
+    const note = text.match(CONTINUED_NOTE)
+    if (note) continued = note[1]
+    else turns.push({ kind: "user", ...(at ? { at } : {}), text })
+  }
+  for (const e of state.history ?? []) {
+    const u = e.user
+    const at = iso(u?.timestamp)
+    const note = u?.additional_context?.match(CONTINUED_NOTE)
+    if (note) continued = note[1]
+    if (u?.images?.length) lost.add("images", u.images.length)
+    const content = u?.content ?? ({} as UserContent)
+    if ("Prompt" in content) prompt(content.Prompt.prompt, at)
+    else if ("ToolUseResults" in content) results(content.ToolUseResults.tool_use_results ?? [], at)
+    else if ("CancelledToolUses" in content) {
+      results(content.CancelledToolUses.tool_use_results ?? [], at)
+      prompt(content.CancelledToolUses.prompt, at)
+    }
+    const a = e.assistant ?? ({} as AssistantMessage)
+    const reply = "Response" in a ? a.Response : "ToolUse" in a ? a.ToolUse : undefined
+    if (reply?.content?.trim() && reply.content !== NO_REPLY) turns.push({ kind: "assistant", text: reply.content, ...(model ? { model } : {}) })
+    if ("ToolUse" in a)
+      for (const t of a.ToolUse.tool_uses ?? []) {
+        // Q renames a call to a tool it no longer has to "dummy" when it resumes; orig_name is what was called.
+        const name = t.orig_name || t.name
+        const input = t.orig_args ?? t.args ?? {}
+        turns.push({ kind: "tool_call", id: String(t.id), name, toolKind: qToolKind(name, input), input })
+      }
+  }
+  if (state.next_message) lost.add("an unsent message")
+  lost.flush(h)
+  return { turns, ...(continued ? { continued } : {}) }
+}