@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/cline/writer.ts

@@ -0,0 +1,656 @@
+import { randomBytes, randomUUID } from "node:crypto"
+import { copyFileSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { dirname, extname, join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { appSupport, exists, isDir, isRunning, readJson } from "../../fsutil.ts"
+import type { Session, ToolKind, Turn, Usage } from "../../session/types.ts"
+import { countTurns, firstUserText, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { taskReader } from "./reader.ts"
+import {
+  CLINE_TOOLS,
+  type Host,
+  type Mapping,
+  ROO_TOOLS,
+  SHOWN,
+  compareVersions,
+  continuedNote,
+  extensionVersion,
+  hostByApp,
+  stateDb,
+  storageDir,
+  summaryText,
+} from "./records.ts"
+import { backupDb, updateState } from "./vscdb.ts"
+
+// Continues a portable session as a new task in Cline or Roo Code, written where the extension keeps its own
+// (<app>/User/globalStorage/<extension>/tasks/<id>/) and listed in the extension's task history, so it opens
+// from the History view like any task:
+//   api_conversation_history.json  what the model sees: Anthropic-style messages with native tool_use and
+//                                  tool_result blocks, the protocol Cline 3.56 (next-gen models), Cline 4.x
+//                                  and Roo Code (3.38 default, 3.54 only) use
+//   ui_messages.json               what the task panel shows: the task, replies, tool rows, command output
+//   Cline: task_metadata.json, and an entry in state/taskHistory.json (Cline 3.56 watches the file and picks up
+//          external changes; Cline 4.x reads it as its legacy task list and moves the task into its SDK store
+//          on resume, src/sdk/sdk-task-history.ts)
+//   Roo 3.49+: tasks/<id>/history_item.json, the source of truth its TaskHistoryStore reconciles from disk,
+//          and tasks/_index.json when it exists
+//   Roo before 3.49: an entry in the taskHistory of its globalState row in the app's state.vscdb, written
+//          only with the app closed and after a backup
+//
+// The task panel and the model read different files, so the note saying where the task came from is a text
+// block in the first API message only: the model reads it, the panel does not show it. Tool calls are mapped
+// to the extension's own tools where the shapes translate (records.ts) and keep their names otherwise. Every
+// call gets a result (a missing one is closed as an error), and the folder is read back before it is listed.
+
+interface Flavor {
+  /** Reader id. */
+  tool: string
+  label: string
+  /** The globalStorage folder name, which is the extension id in lower case. */
+  extension: string
+  /** The extension id as its publisher writes it: the key of its globalState row. */
+  stateKey: string
+  /** Versions whose task store and loader the writer was checked against. */
+  tested: string[]
+  tools: Partial<Record<ToolKind, Mapping>>
+}
+
+export const CLINE: Flavor = {
+  tool: "cline",
+  label: "Cline",
+  extension: "saoudrizwan.claude-dev",
+  stateKey: "saoudrizwan.claude-dev",
+  tested: ["3.56.2", "4.1.26"],
+  tools: CLINE_TOOLS,
+}
+
+export const ROO: Flavor = {
+  tool: "roo",
+  label: "Roo Code",
+  extension: "rooveterinaryinc.roo-cline",
+  stateKey: "RooVeterinaryInc.roo-cline",
+  tested: ["3.38.1", "3.54.0"],
+  tools: ROO_TOOLS,
+}
+
+/**
+ * Roo's roo-cline.customStoragePath setting moves its whole task store elsewhere (src/utils/storage.ts); the
+ * writer only knows the default place, so it refuses rather than write where Roo does not look.
+ */
+function rooCustomStorage(home: string, app: string): string | undefined {
+  let text = ""
+  try {
+    text = readFileSync(join(appSupport(home), app, "User", "settings.json"), "utf8")
+  } catch {
+    return undefined
+  }
+  return text.match(/"roo-cline\.customStoragePath"\s*:\s*"([^"]+)"/)?.[1]
+}
+
+/** Roo moved its task list out of globalState into per-task files in 3.49.0 ("per-task file-based history store"). */
+const ROO_FILE_INDEX = "3.49.0"
+const usesStateDb = (f: Flavor, version: string) => f === ROO && compareVersions(version, ROO_FILE_INDEX) < 0
+
+const ALNUM = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+const randomId = (prefix: string, n: number) => prefix + [...randomBytes(n)].map((b) => ALNUM[b % ALNUM.length]).join("")
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+const oneLine = (s: string) => s.replace(/\s+/g, " ").trim()
+
+/** Cline's ulid: 10 Crockford base32 characters of time, then 16 random ones. */
+function ulid(ms: number): string {
+  const B32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+  let t = ms
+  let time = ""
+  for (let i = 0; i < 10; i++) {
+    time = B32[t % 32]! + time
+    t = Math.floor(t / 32)
+  }
+  return time + [...randomBytes(16)].map((b) => B32[b % 32]).join("")
+}
+
+/** Roo's task ids are uuid v7: 48 bits of time, then random bits. */
+function uuidv7(ms: number): string {
+  const b = randomBytes(16)
+  let t = BigInt(ms)
+  for (let i = 5; i >= 0; i--) {
+    b[i] = Number(t & 0xffn)
+    t >>= 8n
+  }
+  b[6] = (b[6]! & 0x0f) | 0x70
+  b[8] = (b[8]! & 0x3f) | 0x80
+  const h = b.toString("hex")
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`
+}
+
+/** Tool names providers accept: letters, digits, _ and -, at most 64. */
+const apiName = (name: string) => name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "tool"
+
+const asRecord = (v: unknown): Record<string, unknown> =>
+  v && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, unknown>) : { input: v ?? null }
+
+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 Block = Record<string, unknown>
+type Call = Extract<Turn, { kind: "tool_call" }>
+type Result = Extract<Turn, { kind: "tool_result" }>
+
+interface ApiMsg {
+  role: "user" | "assistant"
+  content: Block[]
+  ts: number
+  /** Roo's own compaction: the summary, and the messages it replaced. */
+  isSummary?: true
+  condenseId?: string
+  condenseParent?: string
+}
+
+interface UiMsg {
+  ts: number
+  type: "say" | "ask"
+  say?: string
+  ask?: string
+  text?: string
+  images?: string[]
+  conversationHistoryIndex?: number
+  contextCondense?: Record<string, unknown>
+}
+
+export interface TaskPlan {
+  /** The two task files' records, in the order the extension stores them. */
+  api: Array<Record<string, unknown>>
+  ui: Array<Record<string, unknown>>
+  /** The task's history entry, less its size. */
+  item: Record<string, unknown>
+  /** Cline's task_metadata.json. */
+  metadata?: Record<string, unknown>
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { calls: number }
+}
+
+/** The files of a new task `taskId` continuing `session`. Pure apart from reading attached images. */
+export function planTask(
+  session: Session,
+  flavor: Flavor,
+  opts: { taskId: string; cwd: string; now: Date; version?: string },
+): TaskPlan {
+  const roo = flavor === ROO
+  // The first request is wrapped in <task> by Cline and by Roo 3.38; Roo 3.54 uses <user_message> throughout.
+  const taskTag = !roo || (opts.version !== undefined && usesStateDb(flavor, opts.version)) ? "task" : "user_message"
+  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 title = oneLine(session.header.title ?? firstUserText(session) ?? "") || `${label} session`
+  const results = new Map<string, Result>()
+  const callIds = new Set<string>()
+  for (const t of session.turns) {
+    if (t.kind === "tool_result" && !results.has(t.callId)) results.set(t.callId, t)
+    if (t.kind === "tool_call") callIds.add(t.id)
+  }
+
+  // Timestamps that never go backwards, from the session's own times where it has them.
+  const known = session.turns.map((t) => (t.at ? Date.parse(t.at) : Number.NaN)).find(Number.isFinite)
+  let clock = (known ?? opts.now.getTime() - session.turns.length * 1000) - 1
+  const stamp = (at?: string) => {
+    const t = at ? Date.parse(at) : Number.NaN
+    clock = Number.isFinite(t) && t > clock ? t : clock + 1
+    return clock
+  }
+
+  const msgs: ApiMsg[] = []
+  const ui: UiMsg[] = []
+  // Cline dates each panel row by the API history's length when it appeared: the index of the last message.
+  const row = (fields: Omit<UiMsg, "ts">, ts: number, index: number) => {
+    const r: UiMsg = { ts, ...fields }
+    if (!roo) r.conversationHistoryIndex = index
+    ui.push(r)
+    return r
+  }
+  const note = { type: "text", text: continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10)) }
+  const first: ApiMsg = { role: "user", content: [note], ts: stamp() }
+  msgs.push(first)
+  /** The user message new text joins, so roles alternate: the first message, or a message of tool results. */
+  let open: ApiMsg | undefined = first
+  let hasTask = false
+  const firstReal = session.turns.find((t) => t.kind === "user" || t.kind === "assistant" || t.kind === "tool_call" || t.kind === "compaction")
+  if (firstReal?.kind !== "user") {
+    // The panel's first row is the task; a session that starts mid-way gets its title there.
+    row({ type: "say", say: "text", text: title }, first.ts, -1)
+    hasTask = true
+  }
+
+  let cur: { msg: ApiMsg; index: number; req: UiMsg; usage: Required<Usage>; calls: Array<{ call: Call; id: string; name: string; input: Block }> } | undefined
+  let reasoning: Array<{ text: string; at?: string }> = []
+  let calls = 0
+  let tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+
+  const flushReasoning = (index: number) => {
+    for (const r of reasoning) row({ type: "say", say: "reasoning", text: r.text }, stamp(r.at), index)
+    reasoning = []
+  }
+  const openAssistant = (at?: string) => {
+    if (cur) return cur
+    const index = msgs.length - 1
+    const ts = stamp(at)
+    const req = row({ type: "say", say: "api_req_started", text: "" }, ts, index)
+    flushReasoning(index)
+    cur = { msg: { role: "assistant", content: [], ts }, index, req, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, calls: [] }
+    return cur
+  }
+  const closeAssistant = () => {
+    if (!cur) return
+    const c = cur
+    cur = undefined
+    msgs.push(c.msg)
+    // Cline's api_req_started row carries the request's usage as JSON; the totals in the task header add these up.
+    c.req.text = JSON.stringify({
+      request: `Carried over from ${label}`,
+      tokensIn: c.usage.input,
+      tokensOut: c.usage.output,
+      cacheWrites: c.usage.cacheWrite,
+      cacheReads: c.usage.cacheRead,
+      cost: 0,
+    })
+    open = undefined
+    if (!c.calls.length) return
+    // Every tool_use is answered in the next user message, results first and in call order.
+    const res: ApiMsg = { role: "user", content: [], ts: stamp() }
+    for (const k of c.calls) {
+      const r = results.get(k.call.id)
+      if (!r) drop("tool calls without a result (closed as errors)")
+      const ok = r?.ok ?? false
+      let output = r?.output ?? "No result was recorded for this call; the session moved on before it finished."
+      if (r?.fullPath) output += `\n\n[Full output: ${r.fullPath}]`
+      if (!output.trim()) output = ok ? "(no output)" : "The call failed."
+      res.content.push({ type: "tool_result", tool_use_id: k.id, content: output, ...(ok ? {} : { is_error: true }) })
+      toolRows(k.name, k.input, output, ok, k.call.name, c.index, r?.at)
+    }
+    msgs.push(res)
+    open = res
+  }
+
+  /** The panel rows for one call, in the vocabulary each extension's chat view renders. */
+  const toolRows = (name: string, input: Block, output: string, ok: boolean, original: string, index: number, at?: string) => {
+    const s = (v: unknown) => (typeof v === "string" ? v : "")
+    const tool = (fields: Record<string, unknown>) =>
+      row(roo ? { type: "ask", ask: "tool", text: JSON.stringify(fields) } : { type: "say", say: "tool", text: JSON.stringify(fields) }, stamp(at), index)
+    switch (name) {
+      case "execute_command":
+        row(roo ? { type: "ask", ask: "command", text: s(input.command) } : { type: "say", say: "command", text: s(input.command) }, stamp(at), index)
+        row({ type: "say", say: "command_output", text: output }, stamp(at), index)
+        return
+      case "read_file":
+        tool({ tool: "readFile", path: s(input.path), content: s(input.path) })
+        return
+      case "write_to_file":
+        tool({ tool: "newFileCreated", path: s(input.path), content: s(input.content) })
+        return
+      case "replace_in_file":
+        tool({ tool: "editedExistingFile", path: s(input.path), diff: s(input.diff) })
+        return
+      case "search_replace":
+        tool({ tool: "editedExistingFile", path: s(input.file_path), diff: unifiedDiff(s(input.old_string), s(input.new_string)) })
+        return
+      case "search_files":
+        tool({ tool: "searchFiles", path: s(input.path), regex: s(input.regex), ...(input.file_pattern ? { filePattern: input.file_pattern } : {}), content: output })
+        return
+      case "list_files":
+        tool({ tool: input.recursive ? "listFilesRecursive" : "listFilesTopLevel", path: s(input.path), content: output })
+        return
+      case "web_fetch":
+        tool({ tool: "webFetch", path: s(input.url), content: output })
+        return
+      case "ask_followup_question":
+        row({ type: "ask", ask: "followup", text: JSON.stringify(roo ? { question: s(input.question), suggest: [] } : { question: s(input.question), options: [] }) }, stamp(at), index)
+        if (ok) row({ type: "say", say: "user_feedback", text: output }, stamp(at), index)
+        return
+      case "attempt_completion":
+        row({ type: "say", say: "completion_result", text: s(input.result) }, stamp(at), index)
+        return
+    }
+    const mcp = original.match(/^mcp__(.+?)__(.+)$/) ?? original.match(/^mcp--(.+?)--(.+)$/)
+    if (mcp) {
+      const server = { type: "use_mcp_tool", serverName: mcp[1], toolName: mcp[2], arguments: JSON.stringify(input) }
+      row(roo ? { type: "ask", ask: "use_mcp_server", text: JSON.stringify(server) } : { type: "say", say: "use_mcp_server", text: JSON.stringify(server) }, stamp(at), index)
+      row({ type: "say", say: "mcp_server_response", text: output }, stamp(at), index)
+      return
+    }
+    // A tool the panel has no row for is shown as a short note, so the person still sees it ran.
+    const cut = (t: string, n: number) => (t.length > n ? `${t.slice(0, n)}…` : t)
+    const text = `\`${original}\` (carried over from ${label})\n\n\`\`\`\n${cut(JSON.stringify(input), 600)}\n\`\`\`\n\n${ok ? "" : "Failed: "}${cut(output, 600)}`
+    row({ type: "say", say: "info", text }, stamp(at), index)
+  }
+
+  const seen = new Set<string>()
+  let lastSummary = -1
+  for (const t of session.turns) {
+    switch (t.kind) {
+      case "user": {
+        closeAssistant()
+        flushReasoning(msgs.length - 1)
+        const blocks: Block[] = []
+        const images: string[] = []
+        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) {
+            const data = readFileSync(a.path).toString("base64")
+            blocks.push({ type: "image", source: { type: "base64", media_type: mime, data } })
+            images.push(`data:${mime};base64,${data}`)
+          } else drop("images that could not be attached")
+        }
+        if (!text.trim() && !blocks.length) break
+        const tag = hasTask ? "user_message" : taskTag
+        const wrapped = { type: "text", text: `<${tag}>\n${text}\n</${tag}>` }
+        const index = (open ? msgs.indexOf(open) : msgs.length) - 1
+        row({ type: "say", say: hasTask ? "user_feedback" : "text", text, ...(images.length ? { images } : {}) }, stamp(t.at), index)
+        hasTask = true
+        if (open) open.content.push(wrapped, ...blocks)
+        else {
+          open = { role: "user", content: [wrapped, ...blocks], ts: ui.at(-1)!.ts }
+          msgs.push(open)
+        }
+        break
+      }
+      case "assistant": {
+        if (!t.text.trim()) break
+        // Text after a tool call is a new response: it was written after the call's result came back.
+        if (cur?.calls.length) closeAssistant()
+        const c = openAssistant(t.at)
+        c.msg.content.push({ type: "text", text: t.text })
+        row({ type: "say", say: "text", text: t.text }, stamp(t.at), c.index)
+        if (t.usage) {
+          c.usage.input += t.usage.input ?? 0
+          c.usage.output += t.usage.output ?? 0
+          c.usage.cacheRead += t.usage.cacheRead ?? 0
+          c.usage.cacheWrite += t.usage.cacheWrite ?? 0
+          tokens = { input: tokens.input + (t.usage.input ?? 0), output: tokens.output + (t.usage.output ?? 0), cacheRead: tokens.cacheRead + (t.usage.cacheRead ?? 0), cacheWrite: tokens.cacheWrite + (t.usage.cacheWrite ?? 0) }
+        }
+        break
+      }
+      case "tool_call": {
+        if (seen.has(t.id)) break
+        seen.add(t.id)
+        const raw = asRecord(t.input)
+        const mapped = flavor.tools[t.toolKind]?.(raw, t.name)
+        if (mapped && mapped.name !== t.name) drop(`tool calls mapped to ${flavor.label}'s own tools`)
+        const name = mapped?.name ?? apiName(t.name)
+        const input = mapped?.input ?? raw
+        const c = openAssistant(t.at)
+        // A final answer or plan is both the text the person saw and the call's input; the call carries it.
+        const shown = SHOWN[name]
+        const last = c.msg.content.at(-1)
+        if (shown && last?.type === "text" && String(last.text).trim() === String(input[shown] ?? "").trim()) {
+          c.msg.content.pop()
+          for (let i = ui.length - 1; i >= 0; i--)
+            if (ui[i]!.say === "text" && ui[i]!.text === last.text) {
+              ui.splice(i, 1)
+              break
+            }
+        }
+        const id = randomId("toolu_01", 22)
+        c.msg.content.push({ type: "tool_use", id, name, input })
+        c.calls.push({ call: t, id, name, input })
+        calls++
+        break
+      }
+      case "tool_result":
+        // Written right after its call's response; a result closes the response it answers, so a call made
+        // after it is a new response. A result whose call never came is dropped.
+        if (!callIds.has(t.callId)) drop("tool results without a call")
+        else if (cur?.calls.some((k) => k.call.id === t.callId)) closeAssistant()
+        break
+      case "reasoning":
+        // Shown in the panel as the extensions show their own; the API history keeps only signed reasoning.
+        reasoning.push({ text: t.text, ...(t.at ? { at: t.at } : {}) })
+        drop("reasoning (shown in the task, not sent to the model)")
+        break
+      case "compaction": {
+        closeAssistant()
+        flushReasoning(msgs.length - 1)
+        const ts = stamp(t.at)
+        if (roo) {
+          // Roo's own non-destructive condense: every earlier message points at the summary, which the model
+          // reads from on (getEffectiveApiHistory); the note goes with it, since the first message is hidden.
+          // What the person says next joins the summary's message, as Roo 3.54 merges it before each request.
+          const condenseId = randomUUID()
+          for (const m of msgs) m.condenseParent ??= condenseId
+          open = { role: "user", content: [note, { type: "text", text: `## Conversation Summary\n${t.summary}` }], ts, isSummary: true, condenseId }
+          msgs.push(open)
+          row({ type: "say", say: "condense_context", contextCondense: { cost: 0, prevContextTokens: 0, newContextTokens: 0, summary: t.summary, condenseId } }, ts, msgs.length - 1)
+        } else {
+          // Cline's own truncation: conversationHistoryDeletedRange hides the messages between the first
+          // exchange and the summary from every request (ContextManager.getTruncatedMessages).
+          const index = (open ? msgs.indexOf(open) : msgs.length) - 1
+          const block = { type: "text", text: summaryText(label, t.summary) }
+          if (open) open.content.push(block)
+          else {
+            open = { role: "user", content: [block], ts }
+            msgs.push(open)
+          }
+          lastSummary = msgs.indexOf(open)
+          row({ type: "say", say: "tool", text: JSON.stringify({ tool: "summarizeTask", content: t.summary }) }, ts, index)
+        }
+        break
+      }
+      case "file_edit":
+        if (!t.callId || !callIds.has(t.callId)) drop("file edits outside a tool call")
+        break
+      case "subagent":
+        drop("subagent transcripts (their results stay in the parent's tool results)")
+        break
+    }
+  }
+  closeAssistant()
+  flushReasoning(msgs.length - 1)
+
+  const task = ui[0]?.text ?? title
+  const lastTs = ui.at(-1)?.ts ?? first.ts
+  const totals = { tokensIn: tokens.input, tokensOut: tokens.output, cacheWrites: tokens.cacheWrite, cacheReads: tokens.cacheRead, totalCost: 0 }
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  const api = msgs.map((m) =>
+    roo
+      ? { role: m.role, content: m.content, ts: m.ts, ...(m.isSummary ? { isSummary: true, condenseId: m.condenseId } : {}), ...(m.condenseParent ? { condenseParent: m.condenseParent } : {}) }
+      : { role: m.role, content: m.content },
+  )
+  const uiOut = ui.map((r) => ({ ...r }) as Record<string, unknown>)
+  if (roo) {
+    return {
+      api,
+      ui: uiOut,
+      // Listed by the time it was continued, so it sorts with today's tasks.
+      item: { id: opts.taskId, number: 1, ts: Math.max(lastTs, opts.now.getTime()), task, ...totals, workspace: opts.cwd, mode: "code", toolProtocol: "native" },
+      lost,
+      expect: { calls },
+    }
+  }
+  // The deleted range keeps the first exchange and starts again at the summary; with no exchange before it, nothing is hidden.
+  const range: [number, number] | undefined = lastSummary >= 3 ? [2, lastSummary - 1] : undefined
+  const model = session.header.models.at(-1)
+  return {
+    api,
+    ui: uiOut,
+    item: {
+      id: opts.taskId,
+      ulid: ulid(opts.now.getTime()),
+      ts: Math.max(lastTs, opts.now.getTime()),
+      task,
+      ...totals,
+      cwdOnTaskInitialization: opts.cwd,
+      ...(range ? { conversationHistoryDeletedRange: range } : {}),
+      isFavorited: false,
+      ...(model ? { modelId: model } : {}),
+    },
+    metadata: {
+      files_in_context: [],
+      model_usage: session.header.models.map((m) => ({ ts: first.ts, model_id: m, model_provider_id: providerOf(m), mode: "act" })),
+      environment_history: [],
+    },
+    lost,
+    expect: { calls },
+  }
+}
+
+/** The provider a model belongs to, for task_metadata's model_usage. */
+function providerOf(model: string): string {
+  const slash = model.indexOf("/")
+  if (slash > 0) return model.slice(0, slash)
+  return /claude|opus|sonnet|haiku/i.test(model) ? "anthropic" : /gemini/i.test(model) ? "gemini" : /^(gpt|o\d|codex)/i.test(model) ? "openai" : "unknown"
+}
+
+/** A small unified diff of one replacement, which Roo's edit rows render. */
+function unifiedDiff(before: string, after: string): string {
+  const lines = (s: string, p: string) => (s ? s.split("\n").map((l) => p + l) : [])
+  return ["@@", ...lines(before, "-"), ...lines(after, "+")].join("\n")
+}
+
+/** Writes a file through a temporary name, as the extensions do, so a watcher never sees half of it. */
+function writeAtomic(path: string, data: string) {
+  const tmp = `${path}.tmp.${Date.now()}.${randomBytes(4).toString("hex")}`
+  writeFileSync(tmp, data)
+  renameSync(tmp, path)
+}
+
+const stamp = (d: Date) => d.toISOString().replace(/[:.]/g, "-")
+
+export interface TaskWriterOptions {
+  flavor: Flavor
+  /** The editor whose global storage holds the task: "Code" (VS Code), "Cursor" or "Windsurf". */
+  app: string
+  /** For tests: the installed extension version, and whether a process is running. */
+  version?: string
+  running?: (process: string) => boolean
+}
+
+export function taskWriter(o: TaskWriterOptions): Writer {
+  const host = hostByApp(o.app) as Host
+  const f = o.flavor
+  const tool = o.app === "Code" ? f.tool : `${f.tool}-${o.app.toLowerCase()}`
+  const label = o.app === "Code" ? f.label : `${f.label} (${o.app})`
+  const app = o.app === "Code" ? "VS Code" : o.app
+  const installed = (home: string) => o.version ?? extensionVersion(home, host.app, f.extension)
+  const running = () => (o.running ?? isRunning)(host.process)
+  // Cursor's global storage also holds Cursor's own chats, and Windsurf's its own state: never written while they run.
+  const mustClose = (version: string) => o.app !== "Code" || usesStateDb(f, version)
+
+  return {
+    tool,
+    label,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed(w.home)
+      if (!v) return { ok: false, why: `${f.label} is not installed in ${app}` }
+      if (!f.tested.includes(v)) return { ok: false, why: `${f.label} ${v} is not a version this writer was checked against (${f.tested.join(", ")})` }
+      if (mustClose(v) && running()) return { ok: false, why: `${app} is running; close it first, since ${usesStateDb(f, v) ? `${f.label} ${v} keeps its task list in ${app}'s state database` : `${app} keeps its own state beside ${f.label}'s tasks`}` }
+      if (usesStateDb(f, v) && !exists(stateDb(w.home, host.app))) return { ok: false, why: `${app} has no state database yet (${stateDb(w.home, host.app)}); open ${f.label} in ${app} once first` }
+      const custom = f === ROO ? rooCustomStorage(w.home, host.app) : undefined
+      if (custom) return { ok: false, why: `${f.label} keeps its tasks in ${custom} (roo-cline.customStoragePath); this writer only writes to ${app}'s own storage` }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; ${f.label} lists a task under the folder it ran in` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const version = installed(w.home) ?? f.tested.at(-1)!
+      const now = new Date()
+      const root = storageDir(w.home, host.app, f.extension)
+      const tasks = join(root, "tasks")
+      let taskId: string
+      if (f === ROO) taskId = uuidv7(now.getTime())
+      else {
+        let n = now.getTime()
+        while (exists(join(tasks, String(n)))) n++
+        taskId = String(n)
+      }
+      const dir = join(tasks, taskId)
+      const plan = planTask(session, f, { taskId, cwd: w.cwd, now, version })
+
+      const files: Array<[string, string]> = [
+        [join(dir, "api_conversation_history.json"), JSON.stringify(plan.api)],
+        [join(dir, "ui_messages.json"), JSON.stringify(plan.ui)],
+      ]
+      if (plan.metadata) files.push([join(dir, "task_metadata.json"), JSON.stringify(plan.metadata, null, 2)])
+      const item: Record<string, unknown> = { ...plan.item, size: files.reduce((n, [, data]) => n + Buffer.byteLength(data), 0) }
+      const db = usesStateDb(f, version)
+      const fileIndex = f === ROO && !db
+      if (fileIndex) files.push([join(dir, "history_item.json"), JSON.stringify(item, null, "\t")])
+      const index = db ? stateDb(w.home, host.app) : fileIndex ? join(tasks, "_index.json") : join(root, "state", "taskHistory.json")
+      const written = [...files.map(([p]) => p), index]
+      const result = (): WriteResult => ({
+        tool,
+        way: "native",
+        sessionId: taskId,
+        written,
+        open: `${host.cli} ${shellQuote(w.cwd)}`,
+        note: `In ${app}, open ${f.label}, click History, and pick "${oneLine(String(item.task)).slice(0, 80)}".`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      })
+      if (w.dryRun) return result()
+
+      if (mustClose(version) && running()) throw new Error(`${app} is running; close it before continuing a session in ${f.label}`)
+      if (exists(dir)) throw new Error(`task folder ${dir} already exists`)
+      if (db && !exists(index)) throw new Error(`${app} has no state database yet (${index}); open ${f.label} in ${app} once first`)
+      mkdirSync(dir, { recursive: true })
+      try {
+        // "wx": new files only; an existing task is never touched.
+        for (const [p, data] of files) writeFileSync(p, data, { flag: "wx" })
+        const back = await taskReader({ tool: f.tool, label: f.label, extension: f.extension }).read({ tool: f.tool, sourceId: taskId, path: dir, extra: { host: host.app } }, w.home)
+        const pairs = unpaired(back)
+        const got = countTurns(back).tool_call
+        if (got !== plan.expect.calls || pairs.calls.length || pairs.results.length)
+          throw new Error(`the new ${f.label} task did not read back intact (${got} of ${plan.expect.calls} tool calls, ${pairs.calls.length + pairs.results.length} unpaired)`)
+
+        const backups = join(w.home, ".brain", "backups", f.tool, stamp(now))
+        if (db) {
+          // VS Code holds this table in memory while it runs and writes it back; it is closed (checked above).
+          written.push(...backupDb(index, backups))
+          updateState(index, f.stateKey, (state) => {
+            const history = Array.isArray(state.taskHistory) ? (state.taskHistory as Array<Record<string, unknown>>) : []
+            if (history.some((h) => h?.id === taskId)) throw new Error(`task ${taskId} is already in ${f.label}'s history`)
+            state.taskHistory = [...history, item]
+          })
+        } else if (fileIndex) {
+          // history_item.json is what Roo's store reconciles from; its index is a cache, kept in step when there is one.
+          const cache = readJson<{ version?: number; entries?: Array<Record<string, unknown>> }>(index)
+          if (cache?.version === 1 && Array.isArray(cache.entries)) {
+            written.push(backupFile(index, backups))
+            const entries = [...cache.entries.filter((e) => e?.id !== taskId), item].sort((a, b) => Number(b.ts ?? 0) - Number(a.ts ?? 0))
+            writeAtomic(index, JSON.stringify({ version: 1, updatedAt: now.getTime(), entries }))
+          } else written.pop()
+        } else {
+          const history = readJson<Array<Record<string, unknown>>>(index)
+          if (exists(index) && !Array.isArray(history)) throw new Error(`${index} is not a task list; it was left as it is`)
+          if (exists(index)) written.push(backupFile(index, backups))
+          mkdirSync(dirname(index), { recursive: true })
+          writeAtomic(index, JSON.stringify([...(history ?? []), item]))
+        }
+      } catch (e) {
+        rmSync(dir, { recursive: true, force: true })
+        throw e
+      }
+      return result()
+    },
+  }
+}
+
+function backupFile(path: string, dir: string): string {
+  mkdirSync(dir, { recursive: true })
+  const copy = join(dir, path.split("/").at(-1)!)
+  copyFileSync(path, copy)
+  return copy
+}
+
+/** One writer per extension and editor: VS Code under the extension's own id, the others suffixed. */
+export const taskWriters: Writer[] = [CLINE, ROO].flatMap((flavor) => ["Code", "Cursor", "Windsurf"].map((app) => taskWriter({ flavor, app })))