@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/factory-droid/reader.ts

@@ -0,0 +1,184 @@
+import { readFileSync, statSync } from "node:fs"
+import { join } from "node:path"
+import { exists, gitInfo, ls, mtime } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { clip, header, iso, lossCounter, noteModel } from "../../session/util.ts"
+import { CONTINUED_NOTE } from "../claude-code/records.ts"
+import { patchFiles } from "../codex/records.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { type Event, kindOf, parseEvents, personText, sessionsRoot } from "./records.ts"
+
+// Reads Factory Droid sessions: ~/.factory/sessions/<project key>/<uuid>.jsonl. Messages are read in file
+// order, as Droid loads them. Notices only the person saw (visibility "user_only", hook runs) and context
+// only the model saw ("llm_only", e.g. reminders) are left out; the note a brain writer adds is recognised.
+// Each LLM compaction becomes a compaction turn right after the message it summarised up to, with every
+// earlier turn kept in front of it. Droid's provider-switch serialisations are skipped: they restate the
+// messages that are still in the file.
+
+const PEEK = 64 * 1024
+const DEFAULT_TITLE = "New Session"
+
+type Lost = ReturnType<typeof lossCounter>
+
+/** The text of a content list, counting images it cannot keep. */
+function textOf(content: unknown, lost?: Lost, what = "images"): string {
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return ""
+  const parts: string[] = []
+  for (const b of content as Event[]) {
+    if (b?.type === "text" && typeof b.text === "string") parts.push(b.text)
+    else if (b?.type === "image") lost?.add(what)
+    else if (b?.type === "document") lost?.add("attached documents")
+  }
+  return parts.join("\n")
+}
+
+/** Whether a message is part of the conversation the model and the person both saw. */
+const shared = (m: Event) => m.visibility !== "user_only" && m.visibility !== "llm_only" && m.hiddenFromUserViews !== true && m.hookEventName === undefined
+
+/** One Droid session file as the portable session. */
+export function parseSession(text: string, path: string, home?: string): Session {
+  const events = parseEvents(text)
+  if (!events.length) throw new Error(`${path} is not a Factory Droid session (no session_start line)`)
+  const start = events.find((e) => e.type === "session_start")!
+  const id = String(start.id)
+  const cwd = typeof start.cwd === "string" && start.cwd ? start.cwd : undefined
+  const lost = lossCounter()
+  const turns: Turn[] = []
+  const firstAt = events.find((e) => e.type === "message" && iso(e.timestamp))?.timestamp
+  const h = header("factory-droid", id, { sourcePath: path, project: { ...(cwd ? { cwd, ...gitInfo(cwd, home) } : {}) }, ...(iso(firstAt) ? { startedAt: iso(firstAt) } : {}) })
+
+  const messages = events.filter((e) => e.type === "message" && e.message && typeof e.message === "object")
+  // LLM compactions by the message they summarised up to; one with no anchor summarises a previous session.
+  const after = new Map<number, Event[]>()
+  for (const c of events) {
+    if (c.type !== "compaction_state" || (c.summaryKind ?? "llm_summary") !== "llm_summary" || typeof c.summaryText !== "string") continue
+    let k = typeof c.anchorMessage?.id === "string" ? messages.findIndex((m) => m.id === c.anchorMessage.id) : -1
+    if (k < 0 && typeof c.anchorMessage?.index === "number" && c.anchorMessage.index < messages.length) k = c.anchorMessage.index
+    after.set(k, [...(after.get(k) ?? []), c])
+  }
+  const compaction = (c: Event) => {
+    if (c.summaryText.trim()) turns.push({ kind: "compaction", ...at(c.timestamp), summary: c.summaryText })
+  }
+
+  const calls = new Map<string, Extract<Turn, { kind: "tool_call" }>>()
+  let continued: string | undefined
+  let last: string | undefined
+  for (const c of after.get(-1) ?? []) compaction(c)
+  for (const [i, e] of messages.entries()) {
+    if (typeof e.timestamp === "string") last = e.timestamp
+    const m = e.message as Event
+    const stamp = at(e.timestamp)
+    if (m.visibility === "llm_only") {
+      const note = textOf(m.content).match(CONTINUED_NOTE)
+      if (note) continued = note[1]
+    } else if (shared(m)) {
+      if (m.role === "assistant") assistant(m, stamp)
+      else user(m, stamp)
+    }
+    for (const c of after.get(i) ?? []) compaction(c)
+  }
+
+  function assistant(m: Event, stamp: { at?: string }) {
+    const model = typeof m.modelId === "string" ? m.modelId : undefined
+    noteModel(h, model)
+    for (const b of Array.isArray(m.content) ? (m.content as Event[]) : [{ type: "text", text: String(m.content ?? "") }]) {
+      if (b?.type === "text" && typeof b.text === "string" && b.text.trim()) turns.push({ kind: "assistant", ...stamp, text: b.text, ...(model ? { model } : {}) })
+      else if (b?.type === "thinking") {
+        if (typeof b.thinking === "string" && b.thinking.trim()) turns.push({ kind: "reasoning", ...stamp, text: b.thinking })
+        else if (b.signature) lost.add("signed reasoning")
+      } else if (b?.type === "redacted_thinking") lost.add("redacted reasoning")
+      else if (b?.type === "tool_use" && typeof b.id === "string") {
+        // Droid renames MultiEdit to Edit when it loads a session.
+        const name = b.name === "MultiEdit" ? "Edit" : typeof b.name === "string" ? b.name : "tool"
+        const call: Extract<Turn, { kind: "tool_call" }> = { kind: "tool_call", ...stamp, id: b.id, name, toolKind: kindOf(name), input: b.input ?? {} }
+        calls.set(b.id, call)
+        turns.push(call)
+      } else if (b?.type === "image") lost.add("images")
+    }
+  }
+
+  function user(m: Event, stamp: { at?: string }) {
+    const blocks = Array.isArray(m.content) ? (m.content as Event[]) : [{ type: "text", text: String(m.content ?? "") }]
+    for (const b of blocks) {
+      if (b?.type !== "tool_result" || typeof b.tool_use_id !== "string") continue
+      const full = clip(textOf(b.content, lost, "tool result images"))
+      const ok = b.is_error !== true
+      turns.push({ kind: "tool_result", ...stamp, callId: b.tool_use_id, ok, output: full.text, ...(full.truncated ? { truncated: true } : {}) })
+      const call = calls.get(b.tool_use_id)
+      const input = (call?.input ?? {}) as Event
+      if (!ok || !call) continue
+      if ((call.name === "Edit" || call.name === "Create") && typeof input.file_path === "string") turns.push({ kind: "file_edit", ...stamp, path: input.file_path, callId: call.id })
+      else if (call.name === "ApplyPatch" && typeof input.input === "string")
+        for (const f of patchFiles(input.input)) turns.push({ kind: "file_edit", ...stamp, path: f.path, patch: f.patch, callId: call.id })
+    }
+    // Text beside tool results is what the person typed while the tools ran; reminders are not theirs.
+    const text = textOf(blocks.filter((b) => b?.type !== "tool_result"), lost)
+    if (personText(text)) turns.push({ kind: "user", ...stamp, text: personText(text) })
+  }
+
+  const title = typeof start.title === "string" && start.title.trim() && start.title !== DEFAULT_TITLE ? start.title.trim() : undefined
+  h.title = title ?? (turns.find((t) => t.kind === "user") as Extract<Turn, { kind: "user" }> | undefined)?.text.replace(/\s+/g, " ").trim().slice(0, 80)
+  if (!h.title) delete h.title
+  const updated = iso(last)
+  if (updated) h.updatedAt = updated
+  if (continued) h.parent = { id: continued, kind: "continued" }
+  else if (typeof start.parent === "string" && start.parent) h.parent = { id: `factory-droid:${start.parent}`, kind: "fork" }
+  else if (typeof start.callingSessionId === "string" && start.callingSessionId) h.parent = { id: `factory-droid:${start.callingSessionId}`, kind: "subagent" }
+  lost.flush(h)
+  return { header: h, turns }
+}
+
+function at(v: unknown): { at?: string } {
+  const t = iso(v)
+  return t ? { at: t } : {}
+}
+
+/** The session_start line and the first request, from the start and end of a file; undefined for a file with no messages. */
+async function peek(path: string): Promise<Omit<SessionRef, "tool" | "path"> | undefined> {
+  const file = Bun.file(path)
+  const text = file.size <= 4 * PEEK ? await file.text() : `${await file.slice(0, PEEK).text()}\n${await file.slice(file.size - PEEK).text()}`
+  const events = parseEvents(text)
+  const start = events.find((e) => e.type === "session_start")
+  // Droid's picker leaves out empty sessions and mission workers.
+  if (!start || start.decompSessionType === "worker" || !events.some((e) => e.type === "message")) return undefined
+  const first = events.find((e) => e.type === "message" && e.message?.role === "user" && shared(e.message) && !(e.message.content as Event[] | undefined)?.some?.((b) => b?.type === "tool_result"))
+  const named = typeof start.title === "string" && start.title.trim() && start.title !== DEFAULT_TITLE ? start.title.trim() : undefined
+  const title = named ?? (first ? textOf(first.message.content).replace(/\s+/g, " ").trim().slice(0, 80) || undefined : undefined)
+  return {
+    sourceId: String(start.id),
+    ...(title ? { title } : {}),
+    ...(typeof start.cwd === "string" && start.cwd ? { cwd: start.cwd } : {}),
+    ...(mtime(path) ? { updatedAt: mtime(path) } : {}),
+  }
+}
+
+export const factoryDroidReader: Reader = {
+  tool: "factory-droid",
+  label: "Factory Droid",
+
+  async list(home: string): Promise<SessionRef[]> {
+    const root = sessionsRoot(home)
+    const refs: SessionRef[] = []
+    for (const project of ls(root)) {
+      const dir = join(root, project)
+      for (const name of ls(dir)) {
+        if (!name.endsWith(".jsonl")) continue
+        const path = join(dir, name)
+        try {
+          if (!statSync(path).isFile()) continue
+          const p = await peek(path)
+          if (p) refs.push({ tool: "factory-droid", path, ...p })
+        } catch {
+          // Deleted or unreadable between listing and reading: not a session to offer.
+        }
+      }
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref: SessionRef, home: string): Promise<Session> {
+    if (!exists(ref.path)) throw new Error(`no Factory Droid session at ${ref.path}`)
+    return parseSession(readFileSync(ref.path, "utf8"), ref.path, home)
+  },
+}

package/src/adapters/factory-droid/records.ts

@@ -0,0 +1,79 @@
+import { realpathSync } from "node:fs"
+import { join, resolve } from "node:path"
+import type { ToolKind } from "../../session/types.ts"
+import { toolKindOf } from "../../session/util.ts"
+
+// Facts about Factory Droid's session files, read from the JavaScript bundled in the droid 1.6.0 binary
+// (the session store's loader, the message serializer and the tool definitions). Droid is closed source;
+// see docs/sessions/2026-11-08-session-formats.md, entry 51.
+//
+// ~/.factory/sessions/<project key>/<uuid>.jsonl (FACTORY_HOME_OVERRIDE moves ~/.factory's parent, which
+// brain does not follow). The first line is {type:"session_start", id, title, owner, version:2, cwd}; a file
+// without one is not a session. Then one event per line: "message" events hold Anthropic-style messages
+// ({role:"user"|"assistant", content:[text|image|thinking|redacted_thinking|tool_use|tool_result]}),
+// loaded in file order; a user message holding tool_result blocks is a tool message. A message's
+// `visibility` is "user_only" for notices the model never sees and "llm_only" for context the person
+// never sees. "compaction_state" events carry a summary and an anchor: the model's context is the summary
+// plus the messages after the anchor. Other event types are bookkeeping. A <uuid>.settings.json beside the
+// file holds the model and token totals; Droid creates it when it first opens a session without one.
+
+/**
+ * The person's own words in a user message: Droid's reminders (and the ones Claude Code attaches to a message) come
+ * as `<system-reminder>` blocks, so those are taken off the front and what is left is theirs. A message that is only
+ * reminders has nothing of the person's in it. A session whose first words follow a reminder is not mistaken for one.
+ */
+export function personText(text: string): string {
+  return text.replace(/^(?:\s*<system-reminder>[\s\S]*?<\/system-reminder>)+/, "").trim()
+}
+
+export type Event = Record<string, any>
+
+export const sessionsRoot = (home: string) => join(home, ".factory", "sessions")
+
+/** The project key Droid files a folder's sessions under: "-" and the resolved path, its slashes turned into "-". */
+export function projectKey(cwd: string): string {
+  let p = resolve(cwd)
+  try {
+    p = realpathSync(p)
+  } catch {
+    // a folder that does not exist yet: Droid uses the path as given
+  }
+  return `-${p.replace(/[\\/]+$/, "").replace(/^\/+/, "").replace(/\/+/g, "-")}`
+}
+
+/** Every event of a session file; none when there is no session_start line (Droid's own check). */
+export function parseEvents(text: string): Event[] {
+  const out: Event[] = []
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue
+    try {
+      out.push(JSON.parse(line))
+    } catch {
+      // a half-written line: Droid skips it too
+    }
+  }
+  return out.some((e) => e?.type === "session_start" && typeof e.id === "string") ? out : []
+}
+
+/** Droid's built-in tools, by the name the model calls them. */
+const DROID_KINDS: Record<string, ToolKind> = {
+  Read: "read",
+  Edit: "edit",
+  MultiEdit: "edit",
+  ApplyPatch: "edit",
+  Create: "write",
+  Execute: "shell",
+  LS: "list",
+  Grep: "search",
+  Glob: "search",
+  WebSearch: "web",
+  FetchUrl: "web",
+  Task: "task",
+  TodoWrite: "todo",
+  AskUser: "ask",
+}
+
+export const kindOf = (name: string): ToolKind => DROID_KINDS[name] ?? toolKindOf(name)
+
+/** JSON for one line, with the two line separators escaped as Droid writes them. */
+export const line = (v: unknown) => JSON.stringify(v).replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029")

package/src/adapters/factory-droid/writer.ts

@@ -0,0 +1,350 @@
+import { randomUUID } from "node:crypto"
+import { mkdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { userInfo } from "node:os"
+import { dirname, extname, join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir, versionOf } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { countTurns, firstUserText, unpaired } from "../../session/util.ts"
+import { continuedNote } from "../claude-code/records.ts"
+import { commandOf } from "../pi/writer.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { parseSession } from "./reader.ts"
+import { type Event, line, personText, projectKey, sessionsRoot } from "./records.ts"
+
+// Continues a portable session as a new Factory Droid session: one file, <sessions>/<project key>/<uuid>.jsonl,
+// with the session_start line and message events Droid writes itself (its own importedHistory path writes
+// the same lines). `droid --resume <id>` loads it, its session picker and `droid search` list it, and Droid
+// adds the .settings.json companion with the person's default model when it first opens the session.
+//
+// Messages are Anthropic-style, as Droid stores them: each response is one assistant message with its text
+// and tool_use blocks, and the results of its calls follow in one user message of tool_result blocks.
+// Calls from other tools become Droid's own Read / Create / Edit / Execute / Grep / Glob / LS when their
+// arguments map; others keep their names. The note saying where the session came from is a user message
+// with visibility "llm_only": the model reads it, the person never sees it. A compaction is a
+// compaction_state whose anchor is the last message before it, so Droid continues from its summary while
+// the earlier turns stay on screen; the note goes right after the last one, where the model's context starts.
+// Readable reasoning is dropped: Droid's thinking blocks are sent back to the model and need the
+// provider's signature.
+
+/** droid versions whose session format this writer was checked against. */
+export const DROID_TESTED_VERSIONS = ["1.6.0"]
+
+const IMAGE_TYPES: Record<string, string> = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" }
+const IMAGE_LIMIT = 5 * 1024 * 1024
+
+type Call = Extract<Turn, { kind: "tool_call" }>
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+const str = (o: Event, ...keys: string[]): string | undefined => {
+  for (const k of keys) if (typeof o[k] === "string" && o[k]) return o[k] as string
+  return undefined
+}
+const num = (o: Event, key: string, as: string) => (typeof o[key] === "number" ? { [as]: o[key] } : {})
+
+/** A call from another tool as one of Droid's built-in tools, when its arguments say enough; undefined keeps it as it was. */
+export function asDroidTool(call: Call): { name: string; input: Event } | undefined {
+  const i = call.input && typeof call.input === "object" && !Array.isArray(call.input) ? (call.input as Event) : undefined
+  if (!i) return undefined
+  const path = str(i, "file_path", "path", "filePath", "absolute_path", "target_file")
+  switch (call.toolKind) {
+    case "read":
+      return path ? { name: "Read", input: { file_path: path, ...num(i, "offset", "offset"), ...num(i, "limit", "limit") } } : undefined
+    case "write": {
+      const content = i.content ?? i.contents ?? i.file_text
+      return path && typeof content === "string" ? { name: "Create", input: { file_path: path, content } } : undefined
+    }
+    case "edit": {
+      // One replacement only: Droid's Edit has no list of edits.
+      const one = Array.isArray(i.edits) ? (i.edits.length === 1 ? (i.edits[0] as Event) : undefined) : i
+      const oldStr = one?.old_string ?? one?.old_str ?? one?.oldText
+      const newStr = one?.new_string ?? one?.new_str ?? one?.newText
+      if (!path || typeof oldStr !== "string" || typeof newStr !== "string") return undefined
+      const all = i.replace_all === true || i.change_all === true
+      return { name: "Edit", input: { file_path: path, old_str: oldStr, new_str: newStr, ...(all ? { change_all: true } : {}) } }
+    }
+    case "shell": {
+      const command = commandOf(i)
+      return command ? { name: "Execute", input: { command } } : undefined
+    }
+    case "search": {
+      const where = str(i, "path", "folder", "dir_path", "directory")
+      if (/glob|find|file_search/i.test(call.name)) {
+        const patterns = i.patterns ?? i.pattern
+        return typeof patterns === "string" || (Array.isArray(patterns) && patterns.every((p) => typeof p === "string"))
+          ? { name: "Glob", input: { patterns, ...(where ? { folder: where } : {}) } }
+          : undefined
+      }
+      const pattern = str(i, "pattern", "regex", "query")
+      const glob = str(i, "glob_pattern", "glob", "include")
+      return pattern ? { name: "Grep", input: { pattern, ...(where ? { path: where } : {}), ...(glob ? { glob_pattern: glob } : {}) } } : undefined
+    }
+    case "list": {
+      const where = str(i, "directory_path", "path", "dir_path", "target_directory", "directory", "folder")
+      return { name: "LS", input: where ? { directory_path: where } : {} }
+    }
+    default:
+      return undefined
+  }
+}
+
+export interface DroidPlan {
+  /** The session_start line and every event, in order. */
+  lines: Event[]
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+}
+
+/** The lines of a new Droid session `id` continuing `session`. Pure apart from reading attached images. */
+export function planDroidSession(session: Session, opts: { id: string; now: Date; cwd: string; owner: string }): DroidPlan {
+  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)
+  const expect = { users: 0, assistants: 0, calls: 0 }
+  const title = session.header.title ?? firstUserText(session)?.replace(/\s+/g, " ").trim().slice(0, 60) ?? "Session"
+  // A title set by hand keeps Droid from asking a model to name the session.
+  const lines: Event[] = [{ type: "session_start", id: opts.id, title: `${title} (from ${label})`, isSessionTitleManuallySet: true, owner: opts.owner, version: 2, cwd: opts.cwd }]
+
+  // Timestamps never go backwards; turns without one take the previous time.
+  const known = session.turns.map((t) => (t.at ? Date.parse(t.at) : Number.NaN)).find(Number.isFinite)
+  let clock = (known ?? opts.now.getTime()) - 1
+  const stamp = (at?: string) => {
+    const t = at ? Date.parse(at) : Number.NaN
+    clock = Number.isFinite(t) && t > clock ? t : clock + 1
+    return new Date(clock).toISOString()
+  }
+  let parent: string | undefined
+  let count = 0
+  const message = (m: Event, at?: string) => {
+    const id = randomUUID()
+    lines.push({ type: "message", id, timestamp: stamp(at), ...(parent ? { parentId: parent } : {}), message: m })
+    parent = id
+    count++
+  }
+
+  const note = () => message({ role: "user", content: [{ type: "text", text: continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10)) }], visibility: "llm_only" })
+  const lastCompaction = session.turns.map((t) => t.kind).lastIndexOf("compaction")
+  if (lastCompaction < 0) note()
+
+  // Call ids as the Anthropic format allows them.
+  const ids = new Map<string, string>()
+  const taken = new Set<string>()
+  let remapped = 0
+  let renamed = 0
+  const callId = (id: string) => {
+    let v = ids.get(id)
+    if (v) return v
+    v = /^[A-Za-z0-9_-]{1,64}$/.test(id) && !taken.has(id) ? id : `toolu_${randomUUID().replace(/-/g, "").slice(0, 24)}`
+    if (v !== id) remapped++
+    ids.set(id, v)
+    taken.add(v)
+    return v
+  }
+
+  const written = new Set<string>()
+  const done = new Set<string>()
+  let cur: { at?: string; blocks: Event[]; calls: string[] } | undefined
+  // The results of the last response's calls, until something else comes.
+  let res: { at?: string; blocks: Event[]; calls: string[] } | undefined
+  const closeResults = () => {
+    if (!res) return
+    const r = res
+    res = undefined
+    // Every call is answered before the next request; a call that never got a result is closed as an error.
+    for (const id of r.calls) {
+      if (done.has(id)) continue
+      drop("tool calls without a result (closed as errors)")
+      r.blocks.push({ type: "tool_result", tool_use_id: callId(id), content: "No result was recorded for this call; the session moved on before it finished.", is_error: true })
+      done.add(id)
+    }
+    message({ role: "user", content: r.blocks }, r.at)
+  }
+  const flush = () => {
+    if (cur?.blocks.length) {
+      const c = cur
+      message({ role: "assistant", content: c.blocks }, c.at)
+      if (c.calls.length) res = { blocks: [], calls: c.calls }
+    }
+    cur = undefined
+  }
+  const settle = () => {
+    flush()
+    closeResults()
+  }
+  const assistant = (at?: string) => (cur ??= { ...(at ? { at } : {}), blocks: [], calls: [] })
+
+  for (const [i, t] of session.turns.entries()) {
+    switch (t.kind) {
+      case "user": {
+        settle()
+        const blocks: Event[] = []
+        let text = t.text
+        for (const a of t.attachments ?? []) {
+          if (!a.path) continue // bytes the reader could not keep; it already counted them
+          if (a.kind === "file") {
+            text += `\n\n[Attached file: ${a.path}]`
+            continue
+          }
+          const mime = a.mime ?? IMAGE_TYPES[extname(a.path).toLowerCase()]
+          let size = Number.POSITIVE_INFINITY
+          try {
+            size = statSync(a.path).size
+          } catch {}
+          if (mime && Object.values(IMAGE_TYPES).includes(mime) && size <= IMAGE_LIMIT)
+            blocks.push({ type: "image", source: { type: "base64", media_type: mime, data: readFileSync(a.path).toString("base64") } })
+          else drop("images that could not be attached")
+        }
+        if (!text.trim() && !blocks.length) break
+        message({ role: "user", content: [{ type: "text", text: text.trim() ? text : "(image)" }, ...blocks] }, t.at)
+        // A message that is only reminders reads back as none of the person's, as Droid's own reminders do.
+        if (personText(text) || blocks.length) expect.users++
+        break
+      }
+      case "assistant":
+        // Text after a tool call is a new response: it was written after the call's result came back.
+        if (cur?.calls.length) flush()
+        closeResults()
+        if (!t.text.trim()) break
+        assistant(t.at).blocks.push({ type: "text", text: t.text })
+        expect.assistants++
+        break
+      case "reasoning":
+        if (t.text.trim()) drop("reasoning (Droid sends thinking back to the model, which needs the provider's signature)")
+        break
+      case "tool_call": {
+        if (written.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        closeResults()
+        const d = asDroidTool(t)
+        // Unmapped names must still suit the Anthropic tool-name rule.
+        const name = d?.name ?? (t.name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 64) || "tool")
+        if (name !== t.name) renamed++
+        const input = d?.input ?? (t.input && typeof t.input === "object" && !Array.isArray(t.input) ? (t.input as Event) : { input: t.input ?? null })
+        assistant(t.at).blocks.push({ type: "tool_use", id: callId(t.id), name, input })
+        cur!.calls.push(t.id)
+        written.add(t.id)
+        expect.calls++
+        break
+      }
+      case "tool_result": {
+        if (!written.has(t.callId)) {
+          drop("tool results without a call")
+          break
+        }
+        if (done.has(t.callId)) {
+          drop("repeated or late tool results")
+          break
+        }
+        // A result closes the response that made the call.
+        if (cur?.calls.includes(t.callId)) flush()
+        if (!res?.calls.includes(t.callId)) {
+          drop("repeated or late tool results")
+          break
+        }
+        res.at ??= t.at
+        const output = t.fullPath ? `${t.output}\n\n[Full output: ${t.fullPath}]` : t.output
+        res.blocks.push({ type: "tool_result", tool_use_id: callId(t.callId), content: output.trim() ? output : "(no output)", ...(t.ok ? {} : { is_error: true }) })
+        done.add(t.callId)
+        break
+      }
+      case "compaction": {
+        settle()
+        // The anchor is the last message the summary covers; with none it summarises what came before this session.
+        const anchor = parent ? { anchorMessage: { id: parent, index: count - 1 } } : {}
+        lines.push({ type: "compaction_state", id: randomUUID(), timestamp: stamp(t.at), summaryText: t.summary, summaryTokens: Math.round(t.summary.length / 4), summaryKind: "llm_summary", ...anchor, removedCount: count })
+        if (i === lastCompaction) note()
+        break
+      }
+      case "file_edit":
+        if (!t.callId || !written.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
+    }
+  }
+  settle()
+  if (!expect.users && !expect.assistants && !expect.calls) throw new Error("nothing to continue: the session has no messages or tool calls")
+
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  if (renamed) lost.push(`original tool names (${renamed} calls renamed to Droid's tools or to fit its rules)`)
+  if (remapped) lost.push(`tool call ids remapped (${remapped})`)
+  return { lines, lost, expect }
+}
+
+/** droid's version from `droid --version` ("1.6.0"), or undefined when it is missing. */
+export function droidVersion(): string | undefined {
+  return versionOf("droid")?.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/)?.[1]
+}
+
+/** Droid records the folder as the process saw it: the resolved path (/private/tmp, not /tmp). */
+function realCwd(cwd: string): string {
+  try {
+    return realpathSync(cwd)
+  } catch {
+    return cwd
+  }
+}
+
+function currentUser(): string {
+  try {
+    return userInfo().username
+  } catch {
+    return "unknown"
+  }
+}
+
+/** `version` and `owner` are for tests, which must not depend on the installed binary or the account. */
+export function factoryDroidWriter(o: { version?: string; owner?: string } = {}): Writer {
+  const installed = () => o.version ?? droidVersion()
+  return {
+    tool: "factory-droid",
+    label: "Factory Droid",
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed()
+      if (!v) return { ok: false, why: "Factory Droid is not installed here (`droid --version` failed)" }
+      if (!DROID_TESTED_VERSIONS.includes(v)) return { ok: false, why: `Factory Droid ${v} is not a version this writer was checked against (${DROID_TESTED_VERSIONS.join(", ")})` }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; Droid keeps sessions by the folder they belong to` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const cwd = realCwd(w.cwd)
+      const dir = join(sessionsRoot(w.home), projectKey(cwd))
+      let id = randomUUID()
+      while (exists(join(dir, `${id}.jsonl`))) id = randomUUID()
+      const path = join(dir, `${id}.jsonl`)
+      const plan = planDroidSession(session, { id, now: new Date(), cwd, owner: o.owner ?? currentUser() })
+      if (!w.dryRun) {
+        // Droid keeps its session folders and files private to the account.
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 })
+        // "wx": a new file only; an existing session is never touched.
+        writeFileSync(path, `${plan.lines.map(line).join("\n")}\n`, { flag: "wx", mode: 0o600 })
+        const back = parseSession(readFileSync(path, "utf8"), path, 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) {
+          rmSync(path, { force: true })
+          throw new Error(
+            `the Droid 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`,
+          )
+        }
+      }
+      return {
+        tool: "factory-droid",
+        way: "native",
+        sessionId: id,
+        written: [path],
+        open: `cd ${shellQuote(cwd)} && droid --resume ${id}`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}