@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/opencode/writer.ts

@@ -0,0 +1,379 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir, versionOf } from "../../fsutil.ts"
+import type { Session, Turn, Usage } from "../../session/types.ts"
+import { imageDataUrl } from "../../session/attachments.ts"
+import { firstUserText } from "../../session/util.ts"
+import type { Readiness, WriteResult, Writer } from "../types.ts"
+import type { Bundle } from "./reader.ts"
+import { idMinter, mintId, random62 } from "./ids.ts"
+import { continuedNote } from "./note.ts"
+import { HUNDREDX, OPENCODE_V1, mapCall, type Dialect } from "./tools.ts"
+
+// Continuing a session in OpenCode 1.x, 100xprompt or Kilo through their own importer: the session is written
+// as the JSON `export` produces, {info, messages: [{info, parts}]}, and `<tool> import <file>` stores it as a
+// new session under the project of the folder it runs in. 100xprompt's importer writes the records as they
+// are, unchecked; OpenCode 1.18's and Kilo's decode each against their schema and replace the projectID and
+// directory with the folder's. So every record is complete and valid for all three.
+//
+// Verified live (2026-11-08, temp homes, no network): the real `import`, then `session list` and `export`,
+// on 100xprompt 0.1.136, OpenCode 1.18.25 and Kilo 7.8.27. Shapes checked against 100xprompt's source
+// (src/6-harness/session/message-v2.ts, src/9-surface/cli/cmd/{export,import}.ts), OpenCode v1.18.25 and
+// Kilo's packages/opencode/src/cli/cmd/import.ts with packages/schema/src/v1/session.ts.
+// OpenCode 2.x imports a different format (v2.ts).
+
+export interface Target {
+  tool: string
+  label: string
+  /** The binary's name, and its install folder under home (~/.100xprompt/bin, ~/.opencode/bin, ~/.kilo/bin). */
+  bin: string
+  installDir: string
+  /** Versions whose import format was checked. */
+  tested: string[]
+  /** OpenCode's and Kilo's session schema require a slug; 100xprompt's has none. */
+  slug: boolean
+  dialect: Dialect
+}
+
+export const HUNDREDX_TARGET: Target = { tool: "100xprompt", label: "100xprompt", bin: "100xprompt", installDir: ".100xprompt", tested: ["0.1.136"], slug: false, dialect: HUNDREDX }
+export const OPENCODE_TARGET: Target = { tool: "opencode", label: "OpenCode", bin: "opencode", installDir: ".opencode", tested: ["1.18.25"], slug: true, dialect: OPENCODE_V1 }
+
+/** The binary to run: the installer's copy under home first, else whatever is on PATH. */
+export function resolveBin(t: Pick<Target, "bin" | "installDir">, home: string): { path: string; command: string } {
+  const own = join(home, t.installDir, "bin", t.bin)
+  if (exists(own)) return { path: own, command: Bun.which(t.bin) === own ? t.bin : own }
+  return { path: t.bin, command: t.bin }
+}
+
+export const versionNumber = (v: string | undefined) => v?.match(/\d+\.\d+\.\d+/)?.[0]
+
+export function importWriter(t: Target): Writer {
+  return {
+    tool: t.tool,
+    label: t.label,
+    way: "import",
+    async ready(opts): Promise<Readiness> {
+      const bin = resolveBin(t, opts.home)
+      const raw = versionOf(bin.path)
+      const v = versionNumber(raw)
+      if (!raw) return { ok: false, why: `${t.label} is not installed (no ${t.bin} on PATH or in ~/${t.installDir}/bin)` }
+      if (!v || !t.tested.includes(v)) return { ok: false, why: `${t.label} ${v ?? raw} has not been tested; the import format was checked on ${t.tested.join(", ")}` }
+      if (!isDir(opts.cwd)) return { ok: false, why: `the folder to continue in does not exist: ${opts.cwd}` }
+      return { ok: true }
+    },
+    async write(session, opts): Promise<WriteResult> {
+      const bin = resolveBin(t, opts.home)
+      const version = versionNumber(versionOf(bin.path)) ?? t.tested.at(-1)!
+      const { bundle, sessionId, lost } = buildExport(session, {
+        label: t.label,
+        dialect: t.dialect,
+        cwd: opts.cwd,
+        version,
+        projectID: projectIdOf(opts.cwd, t.bin),
+        slug: t.slug,
+      })
+      const file = join(opts.home, ".brain", "exports", `${t.tool}-${sessionId}.json`)
+      if (!opts.dryRun) {
+        mkdirSync(dirname(file), { recursive: true })
+        writeFileSync(file, `${JSON.stringify(bundle, null, 2)}\n`)
+      }
+      return {
+        tool: t.tool,
+        way: "import",
+        sessionId,
+        written: [file],
+        // The importer files the session under the project of the folder it runs in, so it runs there.
+        open: `cd ${sh(opts.cwd)} && ${sh(bin.command)} import ${sh(file)} && ${sh(bin.command)} --session ${sessionId}`,
+        lost,
+        dryRun: !!opts.dryRun,
+      }
+    },
+  }
+}
+
+export const sh = (s: string) => (/^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+/**
+ * The project id 100xprompt and OpenCode 1.x give a folder: the repository's first root commit, cached by the
+ * tool in .git/<tool>, or "global" outside a repository. 100xprompt's importer files the session under the id
+ * it computes itself and keeps the record's own; this keeps them in agreement.
+ */
+export function projectIdOf(cwd: string, tool: string): string {
+  let dir = cwd
+  for (let i = 0; i < 30 && dir && dir !== "/"; i++) {
+    const git = join(dir, ".git")
+    if (exists(git)) {
+      // A worktree's .git is a file naming the real git folder, relative or absolute.
+      const gitDir = isDir(git) ? git : resolve(dir, readText(git).replace(/^gitdir:\s*/, "").trim())
+      const cached = readText(join(gitDir, tool)).trim()
+      if (cached) return cached
+      const p = Bun.spawnSync(["git", "rev-list", "--max-parents=0", "--all"], { cwd: dir, stdout: "pipe", stderr: "pipe", timeout: 10_000 })
+      const roots = p.exitCode === 0 ? p.stdout.toString().split("\n").map((x) => x.trim()).filter(Boolean).sort() : []
+      return roots[0] ?? "global"
+    }
+    dir = dirname(dir)
+  }
+  return "global"
+}
+
+function readText(p: string): string {
+  try {
+    return readFileSync(p, "utf8")
+  } catch {
+    return ""
+  }
+}
+
+/** The provider a model name belongs to; "provider/model" names say so themselves. */
+export function modelRef(model: string | undefined): { providerID: string; modelID: string } {
+  if (!model) return { providerID: "unknown", modelID: "unknown" }
+  const slash = model.indexOf("/")
+  if (slash > 0) return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) }
+  const providerID = /claude|opus|sonnet|haiku/i.test(model)
+    ? "anthropic"
+    : /gemini|gemma/i.test(model)
+      ? "google"
+      : /^(gpt|o\d|codex|chatgpt)/i.test(model)
+        ? "openai"
+        : /grok/i.test(model)
+          ? "xai"
+          : /deepseek/i.test(model)
+            ? "deepseek"
+            : "unknown"
+  return { providerID, modelID: model }
+}
+
+export const zeroTokens = () => ({ input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } })
+
+export function addUsage(t: ReturnType<typeof zeroTokens>, u: Usage | undefined) {
+  if (!u) return
+  t.input += u.input ?? 0
+  t.output += u.output ?? 0
+  t.cache.read += u.cacheRead ?? 0
+  t.cache.write += u.cacheWrite ?? 0
+}
+
+/** The short label the tool shows beside a call. */
+export function callTitle(name: string, input: Record<string, unknown>): string {
+  const pick = input.description ?? input.filePath ?? input.file_path ?? input.path ?? input.pattern ?? input.url ?? input.command ?? input.query
+  const text = Array.isArray(pick) ? pick.join(" ") : typeof pick === "string" ? pick : name
+  return text.length > 120 ? `${text.slice(0, 119)}…` : text
+}
+
+/** The new session's title: the source's, marked with where it came from. */
+export function continuedTitle(s: Session): string {
+  const title = (s.header.title ?? firstUserText(s) ?? "").replace(/\s+/g, " ").trim().slice(0, 100) || "Continued session"
+  return `${title} (from ${toolLabel(s.header.tool)})`
+}
+
+export interface ExportOptions {
+  /** The target's name, for what is lost. */
+  label: string
+  dialect: Dialect
+  cwd: string
+  version: string
+  projectID: string
+  slug: boolean
+  /** The clock for new ids and the session's update time (tests pin it). */
+  now?: number
+}
+
+/**
+ * The portable session as an export bundle: the continuation note as the tool's own hidden (synthetic) user
+ * message, one user message per user turn, one assistant message per model step (the text, reasoning and tool
+ * calls up to the results they wait on, as the tools store them), each tool call merged with its result into
+ * one tool part under the target's own tool name, and a compaction as the tool's own compaction pair.
+ */
+export function buildExport(s: Session, o: ExportOptions): { bundle: Bundle; sessionId: string; lost: string[] } {
+  const now = o.now ?? Date.now()
+  // New ids from now, so the imported messages sort in order and after anything already stored.
+  const next = idMinter(now)
+  const sessionId = mintId("ses", now, 1, true)
+  const messages: Bundle["messages"] = []
+  const lost = new Map<string, number>()
+  const drop = (what: string, n = 1) => lost.set(what, (lost.get(what) ?? 0) + n)
+  const mapped = { n: 0 }
+
+  // Times must be numbers and must not go backwards, or the stores read messages out of order.
+  let clock = Date.parse(s.header.startedAt ?? "") || now - s.turns.length * 1000
+  const tick = (at?: string) => {
+    const t = at ? Date.parse(at) : NaN
+    clock = Number.isFinite(t) && t > clock ? t : clock + 1
+    return clock
+  }
+  const firstClock = clock
+
+  const agent = o.dialect.agent ?? "build"
+  let model = modelRef(s.header.models.at(-1))
+  let parentID: string | undefined
+  let step: { info: Record<string, any>; parts: Array<Record<string, any>>; tools: boolean; results: boolean; tokens: ReturnType<typeof zeroTokens> } | undefined
+  const calls = new Map<string, Record<string, any>>()
+  const answered = new Set<string>()
+
+  const user = (parts: (messageID: string, at: number) => Array<Record<string, any>>, at?: string) => {
+    closeStep()
+    const id = next("msg")
+    const created = tick(at)
+    messages.push({ info: { id, sessionID: sessionId, role: "user", time: { created }, agent, model, summary: { diffs: [] } }, parts: parts(id, created) })
+    parentID = id
+    return id
+  }
+  const part = (messageID: string, fields: Record<string, unknown>) => ({ id: next("prt"), sessionID: sessionId, messageID, ...fields })
+  const assistantInfo = (id: string, created: number, extra: Record<string, unknown> = {}) => ({
+    id,
+    sessionID: sessionId,
+    role: "assistant",
+    time: { created, completed: created },
+    parentID,
+    modelID: model.modelID,
+    providerID: model.providerID,
+    mode: agent,
+    agent,
+    path: { cwd: o.cwd, root: o.cwd },
+    ...extra,
+    cost: 0,
+    tokens: zeroTokens(),
+    finish: "stop",
+  })
+
+  // The note first: a synthetic part is sent to the model and hidden in the TUI, like the tools' own nudges.
+  const note = continuedNote(toolLabel(s.header.tool), s.header.id, new Date(now).toISOString().slice(0, 10))
+  user((id, created) => [part(id, { type: "text", text: note, synthetic: true, time: { start: created, end: created } })])
+
+  const openStep = (at?: string) => {
+    if (step && !step.results) return step
+    closeStep()
+    const id = next("msg")
+    step = { info: assistantInfo(id, tick(at)), parts: [], tools: false, results: false, tokens: zeroTokens() }
+    step.parts.push(part(id, { type: "step-start" }))
+    messages.push({ info: step.info, parts: step.parts })
+    return step
+  }
+  function closeStep() {
+    if (!step) return
+    const reason = step.tools ? "tool-calls" : "stop"
+    step.info.finish = reason
+    step.info.tokens = step.tokens
+    step.info.time.completed = clock
+    step.parts.push(part(step.info.id, { type: "step-finish", reason, cost: 0, tokens: step.tokens }))
+    step = undefined
+  }
+
+  for (const t of s.turns as Turn[]) {
+    switch (t.kind) {
+      case "user": {
+        // Kept images are embedded as file parts with a data: URL (what OpenCode stores for a pasted image); the rest
+        // travel by path, which another machine or a later day may not have: the text says they were there.
+        const pics: Array<{ url: string; mime: string; name: string }> = []
+        let n = 0
+        for (const a of t.attachments ?? []) {
+          const url = imageDataUrl(a)
+          if (url) pics.push({ url, mime: url.slice(5, url.indexOf(";")), name: a.name ?? a.path?.split("/").pop() ?? "image" })
+          else n++
+        }
+        if (n) drop("attachments", n)
+        const text = t.text.trim() ? t.text : n ? `(${n} attachment${n > 1 ? "s" : ""} not carried over)` : ""
+        if (!text && !pics.length) break // providers reject an empty user message
+        user((id, created) => [
+          ...(text ? [part(id, { type: "text", text, time: { start: created, end: created } })] : []),
+          ...pics.map((p) => part(id, { type: "file", mime: p.mime, filename: p.name, url: p.url })),
+        ], t.at)
+        break
+      }
+      case "assistant": {
+        if (!t.text.trim()) break
+        if (t.model) model = modelRef(t.model)
+        const st = openStep(t.at)
+        const at = tick(t.at)
+        st.parts.push(part(st.info.id, { type: "text", text: t.text, time: { start: at, end: at } }))
+        addUsage(st.tokens, t.usage)
+        break
+      }
+      case "reasoning": {
+        const st = openStep(t.at)
+        const at = tick(t.at)
+        st.parts.push(part(st.info.id, { type: "reasoning", text: t.text, time: { start: at, end: at } }))
+        // Readable reasoning has no provider signature: 100xprompt shows it but does not send it back, and
+        // OpenCode and Kilo send it to another model as plain text.
+        drop(o.dialect === HUNDREDX ? "reasoning: shown in the session but not sent back to the model" : "reasoning: kept as text, without provider signatures")
+        break
+      }
+      case "tool_call": {
+        const st = openStep(t.at)
+        const at = tick(t.at)
+        const call = mapCall(o.dialect, t.name, t.toolKind, t.input, mapped)
+        // Foreign call ids (toolu_…, call_…, Cursor's) are replaced by fresh ones every provider accepts.
+        const p = part(st.info.id, {
+          type: "tool",
+          callID: `call_${random62(24)}`,
+          tool: call.tool,
+          state: { status: "error", input: call.input, error: "No result was recorded for this call.", time: { start: at, end: at } },
+        })
+        st.parts.push(p)
+        st.tools = true
+        calls.set(t.id, p)
+        break
+      }
+      case "tool_result": {
+        const p = calls.get(t.callId)
+        if (!p) {
+          drop("tool results without a call")
+          break
+        }
+        answered.add(t.callId)
+        const start = p.state.time.start as number
+        const end = Math.max(start, tick(t.at))
+        p.state = t.ok
+          ? {
+              status: "completed",
+              input: p.state.input,
+              output: t.output,
+              title: callTitle(String(p.tool), p.state.input),
+              metadata: t.truncated ? { truncated: true, ...(t.fullPath ? { outputPath: t.fullPath } : {}) } : {},
+              time: { start, end },
+            }
+          : { status: "error", input: p.state.input, error: t.output || "The call failed.", time: { start, end } }
+        if (step) step.results = true
+        break
+      }
+      case "compaction": {
+        // The tool's own pair: a user message with a compaction part, then the summary as an assistant reply.
+        // The loaders send the model only what follows the last such pair.
+        user((id) => [part(id, { type: "compaction", auto: true })], t.at)
+        const id = next("msg")
+        const created = tick(t.at)
+        messages.push({
+          info: assistantInfo(id, created, { summary: true }),
+          parts: [part(id, { type: "text", text: t.summary, time: { start: created, end: created } })],
+        })
+        break
+      }
+      case "file_edit":
+        // Both stores record edits as snapshot hashes of their own shadow repository, which cannot be made up;
+        // an edit made by a call travels as that call.
+        if (!t.callId) drop("file edits not made by a tool call")
+        break
+      case "subagent":
+        drop("subagent sessions (their call and result are kept)")
+        break
+    }
+  }
+  closeStep()
+
+  const unanswered = calls.size - answered.size
+  if (unanswered > 0) drop("calls with no result, marked as failed", unanswered)
+  if (calls.size) drop("tool-call ids replaced", calls.size)
+  if (mapped.n) drop(`tool calls renamed to ${o.label}'s own tools`, mapped.n)
+
+  const info: Record<string, unknown> = {
+    id: sessionId,
+    ...(o.slug ? { slug: `brain-${sessionId.slice(-8).toLowerCase()}` } : {}),
+    projectID: o.projectID,
+    directory: o.cwd,
+    title: continuedTitle(s),
+    version: o.version,
+    time: { created: firstClock, updated: Math.max(now, clock) },
+  }
+  return { bundle: { info, messages }, sessionId, lost: [...lost].map(([what, n]) => `${what} (${n})`) }
+}

package/src/adapters/openhands/index.ts

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { openhandsReader } from "./reader.ts"
+import { openhandsNativeWriter } from "./writer.ts"
+
+// OpenHands CLI: reads its conversation event logs, and continues any session as a new conversation that
+// `openhands --resume <id>` opens.
+export const readers: Reader[] = [openhandsReader]
+export const writers: Writer[] = [openhandsNativeWriter]

package/src/adapters/openhands/reader.ts

@@ -0,0 +1,222 @@
+import { join } from "node:path"
+import { isDir, ls, mtime, readJson } from "../../fsutil.ts"
+import type { Attachment, Session, Turn } from "../../session/types.ts"
+import { clip, header, lossCounter, noteModel } from "../../session/util.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { CONTINUED_NOTE, EVENT_FILE, LABEL, TOOL, conversationsDir, eventTime, openhandsKind } from "./records.ts"
+
+// OpenHands CLI conversations: one folder per conversation, one JSON file per event (see records.ts).
+// Events become turns in index order: user and agent MessageEvents are messages, an ActionEvent is the
+// agent's thought plus one tool call (parallel calls share an llm_response_id), ObservationEvent /
+// AgentErrorEvent / UserRejectObservation are its result, and a Condensation with a summary is a compaction.
+
+type Ev = Record<string, any>
+
+/** Event files in index order; a gap ends the log, as EventLog._scan_and_build_index stops there. */
+export function eventFiles(dir: string): string[] {
+  const byIndex = new Map<number, string>()
+  for (const name of ls(join(dir, "events"))) {
+    const m = name.match(EVENT_FILE)
+    if (m) byIndex.set(Number(m[1]), name)
+  }
+  const out: string[] = []
+  for (let i = 0; byIndex.has(i); i++) out.push(join(dir, "events", byIndex.get(i)!))
+  return out
+}
+
+const texts = (content: unknown): string =>
+  (Array.isArray(content) ? content : [])
+    .filter((c: Ev) => c?.type === "text" && typeof c.text === "string")
+    .map((c: Ev) => c.text as string)
+    .join("")
+
+const images = (content: unknown): number => (Array.isArray(content) ? content : []).filter((c: Ev) => c?.type === "image").reduce((n: number, c: Ev) => n + (Array.isArray(c.image_urls) ? c.image_urls.length : 1), 0)
+
+/** The folder the CLI states in every conversation's system prompt (its agent context suffix). */
+export const workingDir = (dynamic: string | undefined) => dynamic?.match(/^Your current working directory is: (.+)$/m)?.[1]?.trim()
+
+/** Arguments of a tool call as an object when they are JSON, else as the raw string. */
+function args(raw: unknown): unknown {
+  if (typeof raw !== "string") return raw ?? {}
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return raw
+  }
+}
+
+/** The first user message's text, which the CLI shows as the title. */
+function firstPrompt(files: string[]): string | undefined {
+  for (const f of files.slice(0, 50)) {
+    const e = readJson<Ev>(f)
+    if (e?.kind === "MessageEvent" && e.source === "user") {
+      const t = texts(e.llm_message?.content).trim()
+      if (t) return t
+    }
+  }
+  return undefined
+}
+
+export function readConversation(dir: string, id: string): Session {
+  const files = eventFiles(dir)
+  if (!files.length) throw new Error(`no events in the OpenHands conversation ${dir}`)
+  const base = readJson<Ev>(join(dir, "base_state.json"))
+  const h = header(TOOL, id, { sourcePath: dir, project: { cwd: base?.workspace?.working_dir } })
+  noteModel(h, base?.agent?.llm?.model)
+  const lost = lossCounter()
+  const turns: Turn[] = []
+  const calls = new Set<string>()
+  const answered = new Set<string>()
+  let first: string | undefined
+  let last: string | undefined
+
+  const reasoning = (e: Ev, msg?: Ev) => {
+    const text = (msg?.reasoning_content ?? e.reasoning_content) as unknown
+    if (typeof text === "string" && text.trim()) turns.push({ kind: "reasoning", text })
+    const blocks = (msg?.thinking_blocks ?? e.thinking_blocks) as unknown
+    if (Array.isArray(blocks) && blocks.length) lost.add("signed reasoning", blocks.length)
+    const item = (msg?.responses_reasoning_item ?? e.responses_reasoning_item) as Ev | undefined
+    if (item) {
+      const parts = [...(item.summary ?? []), ...(item.content ?? [])].filter((s: unknown) => typeof s === "string" && s.trim())
+      if (parts.length) turns.push({ kind: "reasoning", text: parts.join("\n") })
+      if (item.encrypted_content) lost.add("encrypted reasoning")
+    }
+  }
+  const result = (e: Ev, ok: boolean, output: string) => {
+    const callId = String(e.tool_call_id ?? "")
+    if (!calls.has(callId)) return lost.add("results without a call")
+    if (answered.has(callId)) return lost.add("repeated results")
+    answered.add(callId)
+    const c = clip(output)
+    turns.push({ kind: "tool_result", ...(at(e) ? { at: at(e) } : {}), callId, ok, output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+  }
+  const at = (e: Ev) => eventTime(e.timestamp)
+
+  for (const f of files) {
+    const e = readJson<Ev>(f)
+    if (!e) {
+      lost.add("unreadable events")
+      continue
+    }
+    const when = at(e)
+    if (when) {
+      first ??= when
+      last = when
+    }
+    switch (e.kind) {
+      case "SystemPromptEvent": {
+        const dynamic = texts([e.dynamic_context])
+        const note = dynamic.match(CONTINUED_NOTE)
+        if (note) h.parent = { id: note[1]!, kind: "continued" }
+        h.project.cwd ??= workingDir(dynamic)
+        break
+      }
+      case "MessageEvent": {
+        const msg = (e.llm_message ?? {}) as Ev
+        const text = texts(msg.content)
+        if (e.source === "user") {
+          const n = images(msg.content)
+          const attachments: Attachment[] = Array.from({ length: n }, () => ({ kind: "image" }))
+          if (n) lost.add("images (kept inline by OpenHands, not as files)", n)
+          if (text.trim() || n) turns.push({ kind: "user", ...(when ? { at: when } : {}), text, ...(n ? { attachments } : {}) })
+        } else {
+          reasoning(e, msg)
+          if (text.trim()) turns.push({ kind: "assistant", ...(when ? { at: when } : {}), text, ...(h.models.length ? { model: h.models[0] } : {}) })
+        }
+        break
+      }
+      case "ActionEvent": {
+        reasoning(e)
+        const thought = texts(e.thought)
+        if (thought.trim()) turns.push({ kind: "assistant", ...(when ? { at: when } : {}), text: thought, ...(h.models.length ? { model: h.models[0] } : {}) })
+        const call = (e.tool_call ?? {}) as Ev
+        const id = String(e.tool_call_id ?? call.id ?? "")
+        if (!id || calls.has(id)) {
+          lost.add("tool calls without a usable id")
+          break
+        }
+        calls.add(id)
+        const name = String(e.tool_name ?? call.name ?? "tool")
+        const input = args(call.arguments)
+        turns.push({ kind: "tool_call", ...(when ? { at: when } : {}), id, name, toolKind: openhandsKind(name, input), input })
+        const action = (e.action ?? {}) as Ev
+        if (name === "file_editor" && typeof action.path === "string" && ["create", "str_replace", "insert"].includes(action.command))
+          turns.push({ kind: "file_edit", path: action.path, callId: id })
+        break
+      }
+      case "ObservationEvent": {
+        const obs = (e.observation ?? {}) as Ev
+        if (images(obs.content)) lost.add("images in tool results", images(obs.content))
+        const code = typeof obs.exit_code === "number" ? obs.exit_code : undefined
+        result(e, !obs.is_error && (code === undefined || code === 0 || code === -1), texts(obs.content))
+        break
+      }
+      case "AgentErrorEvent":
+        result(e, false, String(e.error ?? ""))
+        break
+      case "UserRejectObservation":
+        result(e, false, `Action rejected: ${String(e.rejection_reason ?? "")}`)
+        break
+      case "Condensation":
+        if (typeof e.summary === "string" && e.summary.trim()) turns.push({ kind: "compaction", ...(when ? { at: when } : {}), summary: e.summary })
+        break
+      case "CondensationRequest":
+      case "CondensationSummaryEvent":
+      case "ConversationStateUpdateEvent":
+      case "PauseEvent":
+      case "InterruptEvent":
+      case "TokenEvent":
+      case "StreamingDeltaEvent":
+      case "LLMCompletionLogEvent":
+      case "HookExecutionEvent":
+      case "SecurityAnalysisEvent":
+      case "ConversationErrorEvent":
+        break
+      default:
+        lost.add(`unknown event kinds: ${String(e.kind)}`)
+    }
+  }
+  lost.flush(h)
+  h.startedAt = first
+  h.updatedAt = last ?? mtime(dir)
+  const prompt = turns.find((t) => t.kind === "user") as Extract<Turn, { kind: "user" }> | undefined
+  if (prompt) h.title = prompt.text.replace(/\s+/g, " ").trim().slice(0, 80)
+  return { header: h, turns }
+}
+
+export const openhandsReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home: string): Promise<SessionRef[]> {
+    const root = conversationsDir(home)
+    const refs: SessionRef[] = []
+    for (const id of ls(root)) {
+      const dir = join(root, id)
+      if (!isDir(dir)) continue
+      const files = eventFiles(dir)
+      // As the CLI's LocalFileStore lists: a folder with events whose first one has a timestamp.
+      const firstEvent = files[0] ? readJson<Ev>(files[0]) : undefined
+      if (!firstEvent?.timestamp) continue
+      const base = readJson<Ev>(join(dir, "base_state.json"))
+      const cwd = (base?.workspace?.working_dir as string | undefined) ?? (firstEvent.kind === "SystemPromptEvent" ? workingDir(texts([firstEvent.dynamic_context])) : undefined)
+      const lastEvent = readJson<Ev>(files[files.length - 1]!)
+      const title = firstPrompt(files)
+      refs.push({
+        tool: TOOL,
+        sourceId: id,
+        path: dir,
+        ...(title ? { title: title.replace(/\s+/g, " ").trim().slice(0, 80) } : {}),
+        ...(cwd ? { cwd } : {}),
+        updatedAt: eventTime(lastEvent?.timestamp) ?? eventTime(firstEvent.timestamp),
+      })
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref: SessionRef, home: string): Promise<Session> {
+    const dir = ref.path || join(conversationsDir(home), ref.sourceId)
+    if (!isDir(dir)) throw new Error(`no OpenHands conversation at ${dir}`)
+    return readConversation(dir, ref.sourceId)
+  },
+}