@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/devin/writer.ts

@@ -0,0 +1,523 @@
+import { Database } from "bun:sqlite"
+import { randomBytes, randomUUID } from "node:crypto"
+import { chmodSync, linkSync, lstatSync, mkdirSync, rmSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import { imageDataUrl, parseDataUrl } from "../../session/attachments.ts"
+import type { Session, ToolKind, Turn, Usage } from "../../session/types.ts"
+import { countTurns, unpaired } from "../../session/util.ts"
+import { continuedNote } from "../opencode/note.ts"
+import { asRecord, safeToolName } from "../opencode/tools.ts"
+import { callTitle, continuedTitle, sh } from "../opencode/writer.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { readDevin } from "./reader.ts"
+import {
+  COLUMNS,
+  COMPACTION_EXT,
+  DEFAULT_MODEL,
+  LABEL,
+  MIGRATIONS,
+  SCHEMA,
+  SUMMARY_PREFIX,
+  TESTED_VERSIONS,
+  TOOL,
+  acpKindOf,
+  devinBin,
+  devinVersion,
+  imageSize,
+  schemaProblem,
+  storePath,
+  type DevinImage,
+  type DevinMessage,
+  type DevinMessageMeta,
+  type DevinToolCall,
+} from "./records.ts"
+
+// Continues a portable session in Devin CLI as a new session of its shared sessions.db, written as the rows
+// Devin 3000.6.7 writes itself (the native-corpus capture): a sessions row and one message_nodes chain from the
+// root to sessions.main_chain_id. The chain opens with brain's note as a system message; then a user node per
+// prompt (images as base64 `images`), an assistant node per model response (its text, its readable reasoning as
+// `thinking`, its `tool_calls`), and a tool node per result, with the ACP tool_call_state Devin keeps for each
+// call. Prompts go to prompt_history, as session-migrate's writer does. A compaction becomes a system node
+// marked "brain/compaction" (Devin's own summary form is not known), and reads back as a compaction.
+//
+// The write is one BEGIN IMMEDIATE transaction that refuses an id the store already has and reads the session
+// back before committing; the store is backed up first (VACUUM INTO, a consistent copy even while Devin runs).
+// The doc does not say Devin holds the store open, and SQLite's locking covers a concurrent writer, so a running
+// Devin is not refused. A missing store is built with the exact schema-16 text and migrations Devin makes, under
+// a temporary name, and linked into place only if no store appeared meanwhile.
+
+/** The message_nodes.metadata Devin writes for a node that is not part of its system prefix. */
+const NODE_META = JSON.stringify({ summarized_from: null, num_tokens_preceding: null, is_system_prefix: null })
+
+export interface NodeRow {
+  node_id: number
+  parent_node_id: number | null
+  chat_message: DevinMessage
+  created_at: number
+  metadata: string
+}
+
+export interface DevinPlan {
+  id: string
+  /** The sessions row, by column. */
+  session: Record<string, string | number | null>
+  nodes: NodeRow[]
+  prompts: Array<{ content: string; timestamp: number }>
+  states: Array<{ tool_call_id: string; tool_call_json: string; tool_call_update_json: string }>
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number; reasoning: number; compactions: number }
+}
+
+/** A new session id in Devin's slug style that says where the session came from, e.g. "from-claude-code-3f9a1c". */
+export function newSessionId(session: Session, taken: Set<string>): string {
+  const from = session.header.tool.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^[-_]+/, "").slice(0, 40) || "session"
+  for (;;) {
+    const id = `from-${from}-${randomBytes(3).toString("hex")}`
+    if (!taken.has(id)) return id
+  }
+}
+
+function metaOf(
+  source: string,
+  operation: string,
+  at: string,
+  o: { userInput?: boolean; finish?: string; tokens?: number; extensions?: Record<string, unknown>; model?: string } = {},
+): DevinMessageMeta {
+  return {
+    num_tokens: o.tokens ?? null,
+    is_user_input: o.userInput ?? null,
+    request_id: null,
+    metrics: null,
+    finish_reason: o.finish ?? null,
+    ...(o.extensions ? { extensions: o.extensions } : {}),
+    ...(o.model !== undefined ? { started_generation_at: at } : {}),
+    created_at: at,
+    ...(o.model !== undefined ? { generation_model: o.model } : {}),
+    telemetry: { source, operation },
+  }
+}
+
+const FILE_KEYS = ["file_path", "filePath", "path", "target_file", "absolute_path", "file"]
+
+/** A portable call as Devin draws it: an ACP title, kind and the file it touches. */
+function acpView(name: string, kind: ToolKind, input: Record<string, unknown>) {
+  const file = ["read", "edit", "write"].includes(kind) ? FILE_KEYS.map((k) => input[k]).find((v): v is string => typeof v === "string" && !!v) : undefined
+  const title = kind === "read" ? "Read file" : kind === "edit" || kind === "write" ? "Edit file" : callTitle(name, input)
+  return { title, kind: acpKindOf(kind), ...(file ? { locations: [{ path: file }] } : {}) }
+}
+
+/** The rows of a new Devin session continuing `session`. Pure: writes nothing. */
+export function planDevin(session: Session, opts: { id: string; cwd: string; now: Date }): DevinPlan {
+  const drops = new Map<string, number>()
+  const drop = (what: string, n = 1) => drops.set(what, (drops.get(what) ?? 0) + n)
+  const nowSec = Math.floor(opts.now.getTime() / 1000)
+  const nodes: NodeRow[] = []
+  const prompts: DevinPlan["prompts"] = []
+  const states: DevinPlan["states"] = []
+  const expect = { users: 0, assistants: 0, calls: 0, reasoning: 0, compactions: 0 }
+
+  // Node times are whole seconds that never go back and never pass now; the JSON keeps the turn's own time when it fits.
+  let clock = Math.min(nowSec, Math.floor((Date.parse(session.header.startedAt ?? "") || opts.now.getTime()) / 1000))
+  const tick = (at?: string): string => {
+    const ms = at ? Date.parse(at) : NaN
+    const t = Number.isFinite(ms) ? Math.floor(ms / 1000) : NaN
+    if (t > clock) clock = Math.min(t, nowSec)
+    return t === clock ? new Date(ms).toISOString() : new Date(clock * 1000).toISOString()
+  }
+  const push = (chat_message: DevinMessage): NodeRow => {
+    const node: NodeRow = { node_id: nodes.length + 1, parent_node_id: nodes.length || null, chat_message, created_at: clock, metadata: NODE_META }
+    nodes.push(node)
+    return node
+  }
+
+  const sourceModel = session.header.models.at(-1)
+  const devinModel = sourceModel && /^swe-/i.test(sourceModel) ? sourceModel : DEFAULT_MODEL
+  /** The model of the response being written: the first reply's to begin with. */
+  let model = session.turns.find((t): t is Extract<Turn, { kind: "assistant" }> => t.kind === "assistant" && !!t.model)?.model ?? sourceModel ?? devinModel
+
+  interface Call {
+    id: string
+    name: string
+    kind: string
+    view: ReturnType<typeof acpView>
+    input: Record<string, unknown>
+  }
+  const calls = new Map<string, Call>()
+  const answered = new Set<string>()
+  const meta = (c: Call) => ({ "cognition.ai/inferenceToolName": c.name })
+
+  const result = (src: string, ok: boolean, output: string, at?: string) => {
+    const c = calls.get(src)!
+    answered.add(src)
+    const when = tick(at)
+    push({
+      message_id: randomUUID(),
+      role: "tool",
+      content: output,
+      tool_call_id: c.id,
+      metadata: metaOf("tool_result", c.name, when, {
+        extensions: {
+          "chisel/tool_result_meta": ok ? { success: true, kind: c.kind } : { success: false, failure_reason: "ToolError", kind: c.kind },
+          ...(ok ? {} : { "chisel/tool_failure": { reason: "ToolError" } }),
+        },
+      }),
+    })
+    states.push({
+      tool_call_id: c.id,
+      tool_call_json: JSON.stringify({ toolCallId: c.id, title: c.view.title, kind: c.view.kind, ...(c.view.locations ? { locations: c.view.locations } : {}), rawInput: c.input, _meta: meta(c) }),
+      tool_call_update_json: JSON.stringify({
+        toolCallId: c.id,
+        status: ok ? "completed" : "failed",
+        ...(ok ? {} : { content: [{ type: "content", content: { type: "text", text: output } }] }),
+        _meta: meta(c),
+      }),
+    })
+  }
+
+  interface Step {
+    node: NodeRow
+    at: string
+    model: string
+    text: string[]
+    thinking: string[]
+    calls: DevinToolCall[]
+    sources: string[]
+    shown: Record<string, unknown>
+    usage?: Usage
+    results: boolean
+  }
+  let step: Step | undefined
+  const pending: Array<() => void> = []
+
+  const openStep = (at?: string): Step => {
+    if (step && !step.results) return step
+    closeStep()
+    const when = tick(at)
+    // Placeholders in Devin's key order; closeStep fills them.
+    const node = push({ message_id: randomUUID(), role: "assistant", content: "", tool_calls: [], thinking: null, metadata: metaOf("assistant", "inference", when) })
+    step = { node, at: when, model, text: [], thinking: [], calls: [], sources: [], shown: {}, results: false }
+    return step
+  }
+  function closeStep() {
+    if (!step) return
+    const s = step
+    step = undefined
+    const m = s.node.chat_message
+    m.content = s.text.join("\n\n")
+    m.tool_calls = s.calls
+    m.thinking = s.thinking.length ? { thinking: s.thinking.join("\n\n"), signature: "" } : null
+    m.metadata = metaOf("assistant", "inference", s.at, {
+      finish: s.calls.length ? "tool_calls" : "stop",
+      ...(s.usage?.output !== undefined ? { tokens: s.usage.output } : {}),
+      model: s.model,
+      ...(s.calls.length ? { extensions: { "chisel/tool_call_content": s.shown } } : {}),
+    })
+    if (s.text.length) expect.assistants++
+    if (s.thinking.length) expect.reasoning++
+    for (const r of pending.splice(0)) r()
+    // Every call needs its result before the next message, as the model's API requires.
+    for (const src of s.sources)
+      if (!answered.has(src)) {
+        result(src, false, "No result was recorded for this call.")
+        drop("calls with no result, marked as failed")
+      }
+  }
+
+  push({
+    message_id: randomUUID(),
+    role: "system",
+    content: continuedNote(toolLabel(session.header.tool), session.header.id, opts.now.toISOString().slice(0, 10)),
+    metadata: metaOf("system", "unknown", tick(session.header.startedAt)),
+  })
+
+  for (const t of session.turns as Turn[]) {
+    switch (t.kind) {
+      case "user": {
+        const images: DevinImage[] = []
+        let skipped = 0
+        for (const a of t.attachments ?? []) {
+          const url = a.kind === "image" ? parseDataUrl(imageDataUrl(a)) : undefined
+          if (!url) {
+            skipped++
+            drop("attachments (not images, or their files are gone)")
+            continue
+          }
+          images.push({ ...imageSize(Buffer.from(url.base64, "base64")), base64_data: url.base64, mime_type: url.mime, source_path: a.path ?? a.name ?? "", caption: "" })
+        }
+        const text = t.text.trim() ? t.text : skipped ? `(${skipped} attachment${skipped > 1 ? "s" : ""} not carried over)` : ""
+        if (!text && !images.length) break
+        closeStep()
+        const when = tick(t.at)
+        push({
+          message_id: randomUUID(),
+          role: "user",
+          content: text,
+          ...(images.length ? { images } : {}),
+          metadata: metaOf("user", "unknown", when, { userInput: true, ...(text ? { extensions: { "chisel/acp-content-blocks": [{ type: "text", text }] } } : {}) }),
+        })
+        if (text.trim()) prompts.push({ content: text, timestamp: clock })
+        expect.users++
+        break
+      }
+      case "assistant": {
+        if (!t.text.trim()) break
+        if (t.model && t.model !== model) {
+          // A response belongs to one model: text from another starts a new one (its reasoning stays with it).
+          if (step && (step.text.length || step.calls.length)) closeStep()
+          model = t.model
+          if (step) step.model = model
+        }
+        const s = openStep(t.at)
+        s.text.push(t.text)
+        if (t.usage) s.usage = t.usage
+        // Devin's metrics block holds timings this session does not have; only the output count is kept (num_tokens).
+        if (t.usage && (t.usage.input !== undefined || t.usage.cacheRead !== undefined || t.usage.cacheWrite !== undefined)) drop("token usage of replies, other than the output count")
+        break
+      }
+      case "reasoning":
+        if (!t.text.trim()) break
+        openStep(t.at).thinking.push(t.text)
+        drop("reasoning: kept as text, without provider signatures")
+        break
+      case "tool_call": {
+        if (calls.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        const s = openStep(t.at)
+        const raw = t.input
+        if (raw !== undefined && raw !== null && (typeof raw !== "object" || Array.isArray(raw))) drop("tool inputs that were not objects (wrapped)")
+        const input = asRecord(raw)
+        const name = safeToolName(t.name)
+        if (name !== t.name) drop("tool names changed to fit Devin")
+        const view = acpView(name, t.toolKind, input)
+        const id = `call_${randomBytes(12).toString("hex")}`
+        calls.set(t.id, { id, name, kind: view.kind, view, input })
+        s.calls.push({ id, name, arguments: input, index: s.calls.length, kind: "function" })
+        s.sources.push(t.id)
+        s.shown[id] = { toolCallId: id, title: view.title, status: "pending", ...(view.locations ? { locations: view.locations } : {}), kind: view.kind, rawInput: input }
+        expect.calls++
+        break
+      }
+      case "tool_result": {
+        if (!calls.has(t.callId)) {
+          drop("tool results without a call")
+          break
+        }
+        // A result belongs right after the response that made its call; one that comes later (after the next
+        // message, when its call was already closed as failed) has nowhere to go.
+        if (answered.has(t.callId) || !step?.sources.includes(t.callId)) {
+          drop("repeated tool results, or results that came after the conversation moved on")
+          break
+        }
+        const src = t.callId
+        answered.add(src)
+        step.results = true
+        pending.push(() => result(src, t.ok, t.output, t.at))
+        break
+      }
+      case "compaction": {
+        if (!t.summary.trim()) break
+        closeStep()
+        const when = tick(t.at)
+        push({ message_id: randomUUID(), role: "system", content: `${SUMMARY_PREFIX}${t.summary}`, metadata: metaOf("system", "unknown", when, { extensions: { [COMPACTION_EXT]: true } }) })
+        expect.compactions++
+        drop("compactions: kept as a marked system message, the turns before them stay in the history")
+        break
+      }
+      case "file_edit":
+        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 lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  if (calls.size) lost.push(`tool-call ids replaced (${calls.size})`)
+  if (sourceModel && devinModel !== sourceModel) lost.push(`the model: Devin continues on ${devinModel} (the session used ${sourceModel})`)
+  const first = nodes[0]!
+  const last = nodes.at(-1)!
+  return {
+    id: opts.id,
+    session: {
+      id: opts.id,
+      working_directory: opts.cwd,
+      backend_type: "windsurf",
+      model: devinModel,
+      agent_mode: "accept-edits",
+      created_at: first.created_at,
+      last_activity_at: last.created_at,
+      title: continuedTitle(session),
+      main_chain_id: last.node_id,
+      shell_last_seen_index: 0,
+      cogs_json: "[]",
+      workspace_dirs: "[]",
+      hidden: 0,
+      metadata: JSON.stringify({ total_credit_cost: 0, total_acu_cost: 0, response_dimensions: [] }),
+    },
+    nodes,
+    prompts,
+    states,
+    lost,
+    expect,
+  }
+}
+
+/** Inserts the plan in one BEGIN IMMEDIATE transaction and reads it back before committing; any failure rolls it back. */
+export function insertPlan(db: Database, plan: DevinPlan, path: string) {
+  const cols = COLUMNS.sessions!
+  // Prepared statements are finalized here: one left to the garbage collector keeps the connection open.
+  const stmts = [
+    db.prepare(`INSERT INTO sessions (${cols.join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`),
+    db.prepare("INSERT INTO message_nodes (session_id, node_id, parent_node_id, chat_message, created_at, metadata) VALUES (?, ?, ?, ?, ?, ?)"),
+    db.prepare("INSERT INTO prompt_history (content, timestamp, session_id, is_shell) VALUES (?, ?, ?, 0)"),
+    db.prepare("INSERT INTO tool_call_state (session_id, tool_call_id, tool_call_json, tool_call_update_json) VALUES (?, ?, ?, ?)"),
+  ] as const
+  const [session, node, prompt, state] = stmts
+  db.exec("BEGIN IMMEDIATE")
+  try {
+    if (db.query("SELECT 1 FROM sessions WHERE id = ?").get(plan.id)) throw new Error(`refusing to overwrite Devin session ${plan.id}: the store already has it`)
+    session.run(...cols.map((c) => plan.session[c] ?? null))
+    for (const n of plan.nodes) node.run(plan.id, n.node_id, n.parent_node_id, JSON.stringify(n.chat_message), n.created_at, n.metadata)
+    for (const p of plan.prompts) prompt.run(p.content, p.timestamp, plan.id)
+    for (const s of plan.states) state.run(plan.id, s.tool_call_id, s.tool_call_json, s.tool_call_update_json)
+    // Read back as Devin's sessions are read.
+    const back = readDevin(db, plan.id, path)
+    const n = countTurns(back)
+    const pairs = unpaired(back)
+    const e = plan.expect
+    if (n.user !== e.users || n.assistant !== e.assistants || n.tool_call !== e.calls || n.reasoning !== e.reasoning || n.compaction !== e.compactions || pairs.calls.length || pairs.results.length)
+      throw new Error(
+        `the Devin session did not read back as written (users ${n.user}/${e.users}, replies ${n.assistant}/${e.assistants}, tool calls ${n.tool_call}/${e.calls}, reasoning ${n.reasoning}/${e.reasoning}, compactions ${n.compaction}/${e.compactions}, unpaired ${pairs.calls.length + pairs.results.length}); nothing was kept`,
+      )
+    db.exec("COMMIT")
+  } catch (err) {
+    db.exec("ROLLBACK")
+    throw err
+  } finally {
+    for (const st of stmts) st.finalize()
+  }
+}
+
+/** Adds the session to an existing store after a consistent backup. */
+export function addToStore(dbPath: string, plan: DevinPlan, backupFile: string) {
+  if (lstatSync(dbPath).isSymbolicLink()) throw new Error(`the Devin store ${dbPath} is a symbolic link; brain does not write through one`)
+  // readwrite without create: a store removed meanwhile is an error, not a new empty store.
+  const db = new Database(dbPath, { readwrite: true })
+  try {
+    db.exec("PRAGMA busy_timeout = 5000")
+    db.exec("PRAGMA foreign_keys = ON")
+    const problem = schemaProblem(db)
+    if (problem) throw new Error(problem)
+    mkdirSync(dirname(backupFile), { recursive: true, mode: 0o700 })
+    db.run("VACUUM INTO ?", [backupFile])
+    chmodSync(backupFile, 0o600)
+    insertPlan(db, plan, dbPath)
+    try {
+      db.exec("PRAGMA wal_checkpoint(PASSIVE)")
+    } catch {
+      // Devin checkpoints the log itself.
+    }
+  } finally {
+    db.close(true)
+  }
+}
+
+/** Builds a missing store as Devin 3000.6.7 does, with the session in it, and puts it in place atomically. */
+export function createStore(dbPath: string, plan: DevinPlan, now: Date) {
+  const dir = dirname(dbPath)
+  mkdirSync(dir, { recursive: true, mode: 0o700 })
+  const tmp = join(dir, `.sessions.${randomBytes(6).toString("hex")}.db.tmp`)
+  try {
+    const db = new Database(tmp)
+    try {
+      db.exec("PRAGMA journal_mode = WAL")
+      for (const sql of SCHEMA) db.exec(sql)
+      // refinery's applied_on: RFC 3339 with nanoseconds, a moment apart per migration.
+      const base = now.toISOString().slice(0, 23)
+      const add = db.prepare("INSERT INTO refinery_schema_history (version, name, applied_on, checksum) VALUES (?, ?, ?, ?)")
+      MIGRATIONS.forEach(([version, name, checksum], i) => add.run(version, name, `${base}${String(i * 1000).padStart(6, "0")}Z`, checksum))
+      add.finalize()
+      insertPlan(db, plan, dbPath)
+      // Everything into the main file: the -wal of the temporary name cannot follow the link.
+      db.exec("PRAGMA wal_checkpoint(TRUNCATE)")
+    } finally {
+      // Released now, before the file is linked into place: SQLite tracks a WAL store by its inode, and a
+      // connection left open on the temporary name would tie the store's shared memory to that name.
+      db.close(true)
+    }
+    chmodSync(tmp, 0o600)
+    try {
+      linkSync(tmp, dbPath)
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "EEXIST") throw new Error(`a Devin store appeared at ${dbPath} while brain was writing; it was left as it is`)
+      throw err
+    }
+  } finally {
+    for (const side of ["", "-wal", "-shm", "-journal"]) rmSync(tmp + side, { force: true })
+  }
+}
+
+const stamp = (d: Date) => d.toISOString().replace(/[:.]/g, "-")
+
+export const devinWriter: Writer = {
+  tool: TOOL,
+  label: LABEL,
+  way: "native",
+
+  async ready(opts: WriteOptions): Promise<Readiness> {
+    const bin = devinBin()
+    if (!bin) return { ok: false, why: "Devin CLI is not installed (no devin on PATH)" }
+    const { raw, version } = devinVersion(bin)
+    if (!version || !TESTED_VERSIONS.includes(version))
+      return { ok: false, why: `Devin CLI ${version ?? raw ?? "(version unknown)"} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+    if (!isDir(opts.cwd)) return { ok: false, why: `the folder to continue in does not exist: ${opts.cwd}` }
+    const db = storePath(opts.home)
+    if (exists(db)) {
+      let problem: string | undefined
+      try {
+        problem = withSnapshot(db, schemaProblem)
+      } catch (e) {
+        problem = `the Devin store at ${db} cannot be read: ${(e as Error).message}`
+      }
+      if (problem) return { ok: false, why: problem }
+    }
+    return { ok: true }
+  },
+
+  async write(session: Session, opts: WriteOptions): Promise<WriteResult> {
+    const cwd = resolve(opts.cwd)
+    const dbPath = storePath(opts.home)
+    const now = new Date()
+    const had = exists(dbPath)
+    let taken = new Set<string>()
+    if (had) {
+      const seen = withSnapshot(dbPath, (d) => ({ problem: schemaProblem(d), ids: (d.query("SELECT id FROM sessions").all() as Array<{ id: string }>).map((r) => r.id) }))
+      if (seen.problem) throw new Error(seen.problem)
+      taken = new Set(seen.ids)
+    }
+    const plan = planDevin(session, { id: newSessionId(session, taken), cwd, now })
+    const backup = join(opts.home, ".brain", "backups", TOOL, `${stamp(now)}-${plan.id}`, "sessions.db")
+    if (!opts.dryRun) {
+      if (had) addToStore(dbPath, plan, backup)
+      else createStore(dbPath, plan, now)
+    }
+    return {
+      tool: TOOL,
+      way: "native",
+      sessionId: plan.id,
+      written: had ? [dbPath, backup] : [dbPath],
+      // `devin list` shows the sessions of the folder it runs in, so the session is resumed from its own.
+      open: `cd ${sh(cwd)} && devin --resume ${plan.id}`,
+      lost: plan.lost,
+      dryRun: !!opts.dryRun,
+    }
+  },
+}

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

@@ -0,0 +1,12 @@
+import type { Reader, Writer } from "../types.ts"
+import { factoryDroidReader } from "./reader.ts"
+import { factoryDroidWriter } from "./writer.ts"
+
+// Factory Droid (CLI): reads its sessions and continues any session as a new native Droid session,
+// `droid --resume <id>`.
+
+export { DROID_TESTED_VERSIONS, factoryDroidWriter } from "./writer.ts"
+export { factoryDroidReader }
+
+export const readers: Reader[] = [factoryDroidReader]
+export const writers: Writer[] = [factoryDroidWriter()]