diff --git a/packages/opencode/src/cli/cmd/tui/app.tsx b/packages/opencode/src/cli/cmd/tui/app.tsx
index 549c7c34a7..024c89fdc4 100644
--- a/packages/opencode/src/cli/cmd/tui/app.tsx
+++ b/packages/opencode/src/cli/cmd/tui/app.tsx
@@ -42,6 +42,7 @@ import { writeHeapSnapshot } from "v8"
 import { PromptRefProvider, usePromptRef } from "./context/prompt"
 import { TuiConfigProvider } from "./context/tui-config"
 import { TuiConfig } from "@/config/tui"
+import { Mock } from "./mock"
 
 async function getTerminalBackgroundColor(): Promise<"dark" | "light"> {
   // can't set raw mode if not a TTY
@@ -803,6 +804,7 @@ function App() {
       }}
       onMouseUp={Flag.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT ? undefined : () => Selection.copy(renderer, toast)}
     >
+      <Mock />
       <Switch>
         <Match when={route.data.type === "home"}>
           <Home />
diff --git a/packages/opencode/src/cli/cmd/tui/mock.tsx b/packages/opencode/src/cli/cmd/tui/mock.tsx
new file mode 100644
index 0000000000..d50bf8d866
--- /dev/null
+++ b/packages/opencode/src/cli/cmd/tui/mock.tsx
@@ -0,0 +1,109 @@
+import { Flag } from "@/flag/flag"
+import { Filesystem } from "@/util/filesystem"
+import { onMount } from "solid-js"
+import { useLocal } from "./context/local"
+import { usePromptRef } from "./context/prompt"
+import { useRoute } from "./context/route"
+import { useSync } from "./context/sync"
+import { useToast } from "./ui/toast"
+
+const model = {
+  providerID: "mock",
+  modelID: "mock-model",
+}
+
+function parse(raw: string) {
+  try {
+    const json = JSON.parse(raw)
+    return Array.isArray(json) ? json : []
+  } catch {
+    return []
+  }
+}
+
+async function load() {
+  if (Flag.OPENCODE_TUI_RUNNER_FILE) {
+    return parse(await Filesystem.readText(Flag.OPENCODE_TUI_RUNNER_FILE).catch(() => "[]"))
+  }
+
+  return parse(Flag.OPENCODE_TUI_RUNNER_STEPS ?? "[]")
+}
+
+function text(step: unknown) {
+  return typeof step === "string" ? step : JSON.stringify(step)
+}
+
+async function wait<T>(test: () => T | false | undefined, timeout = 30_000) {
+  const start = Date.now()
+
+  while (Date.now() - start < timeout) {
+    const value = test()
+    if (value) return value
+    await Bun.sleep(100)
+  }
+
+  throw new Error("Mock runner timed out")
+}
+
+export function Mock() {
+  const local = useLocal()
+  const prompt = usePromptRef()
+  const route = useRoute()
+  const sync = useSync()
+  const toast = useToast()
+
+  onMount(() => {
+    if (Flag.OPENCODE_TUI_RUNNER !== "mock") return
+
+    void (async () => {
+      const steps = await load()
+      if (!steps.length) {
+        toast.show({
+          message: "Mock runner has no steps",
+          variant: "warning",
+          duration: 3000,
+        })
+        return
+      }
+
+      await wait(() => sync.ready && local.model.ready)
+      await wait(() => !!sync.data.provider.find((item) => item.id === model.providerID)?.models[model.modelID])
+      local.model.set(model, { recent: true })
+
+      for (const step of steps) {
+        await wait(() => !!prompt.current)
+        local.model.set(model)
+
+        const prev = route.data.type === "session" ? route.data.sessionID : undefined
+        const count = prev ? sync.data.message[prev]?.length ?? 0 : 0
+
+        prompt.current!.set({
+          input: text(step),
+          parts: [],
+        })
+        prompt.current!.submit()
+
+        const sid = await wait(() => (route.data.type === "session" ? route.data.sessionID : undefined))
+        await wait(() => {
+          const list = sync.data.message[sid] ?? []
+          if (list.length <= (sid === prev ? count : 0)) return false
+          return sync.session.status(sid) === "idle" && list.at(-1)?.role !== "user"
+        }, 120000)
+      }
+
+      toast.show({
+        message: `Mock runner sent ${steps.length} prompt(s)`,
+        variant: "success",
+        duration: 3000,
+      })
+    })().catch((err) => {
+      toast.show({
+        message: err instanceof Error ? err.message : "Mock runner failed",
+        variant: "error",
+        duration: 5000,
+      })
+    })
+  })
+
+  return <></>
+}
diff --git a/packages/opencode/src/flag/flag.ts b/packages/opencode/src/flag/flag.ts
index 0c55187b9d..a9aed9dfd5 100644
--- a/packages/opencode/src/flag/flag.ts
+++ b/packages/opencode/src/flag/flag.ts
@@ -16,6 +16,9 @@ export namespace Flag {
   export const OPENCODE_CONFIG = process.env["OPENCODE_CONFIG"]
   export declare const OPENCODE_TUI_CONFIG: string | undefined
   export declare const OPENCODE_CONFIG_DIR: string | undefined
+  export const OPENCODE_TUI_RUNNER = process.env["OPENCODE_TUI_RUNNER"]
+  export const OPENCODE_TUI_RUNNER_STEPS = process.env["OPENCODE_TUI_RUNNER_STEPS"]
+  export const OPENCODE_TUI_RUNNER_FILE = process.env["OPENCODE_TUI_RUNNER_FILE"]
   export const OPENCODE_CONFIG_CONTENT = process.env["OPENCODE_CONFIG_CONTENT"]
   export const OPENCODE_DISABLE_AUTOUPDATE = truthy("OPENCODE_DISABLE_AUTOUPDATE")
   export const OPENCODE_ALWAYS_NOTIFY_UPDATE = truthy("OPENCODE_ALWAYS_NOTIFY_UPDATE")
diff --git a/packages/opencode/src/global/index.ts b/packages/opencode/src/global/index.ts
index 869019e2ce..435876b6a7 100644
--- a/packages/opencode/src/global/index.ts
+++ b/packages/opencode/src/global/index.ts
@@ -26,13 +26,15 @@ export namespace Global {
   }
 }
 
-await Promise.all([
-  fs.mkdir(Global.Path.data, { recursive: true }),
-  fs.mkdir(Global.Path.config, { recursive: true }),
-  fs.mkdir(Global.Path.state, { recursive: true }),
-  fs.mkdir(Global.Path.log, { recursive: true }),
-  fs.mkdir(Global.Path.bin, { recursive: true }),
-])
+try {
+  await Promise.all([
+    fs.mkdir(Global.Path.data, { recursive: true }),
+    fs.mkdir(Global.Path.config, { recursive: true }),
+    fs.mkdir(Global.Path.state, { recursive: true }),
+    fs.mkdir(Global.Path.log, { recursive: true }),
+    fs.mkdir(Global.Path.bin, { recursive: true }),
+  ])
+} catch (err) {}
 
 const CACHE_VERSION = "21"
 
diff --git a/packages/opencode/src/provider/models.ts b/packages/opencode/src/provider/models.ts
index bae3317846..ef1f63b767 100644
--- a/packages/opencode/src/provider/models.ts
+++ b/packages/opencode/src/provider/models.ts
@@ -94,7 +94,10 @@ export namespace ModelsDev {
       .catch(() => undefined)
     if (snapshot) return snapshot
     if (Flag.OPENCODE_DISABLE_MODELS_FETCH) return {}
-    const json = await fetch(`${url()}/api.json`).then((x) => x.text())
+    const json = await fetch(`${url()}/api.json`)
+      .then((x) => x.text())
+      .catch(() => undefined)
+    if (!json) return {}
     return JSON.parse(json)
   })
 
diff --git a/packages/opencode/src/provider/provider.ts b/packages/opencode/src/provider/provider.ts
index 6ab45d028b..33ce5cd26d 100644
--- a/packages/opencode/src/provider/provider.ts
+++ b/packages/opencode/src/provider/provider.ts
@@ -30,6 +30,7 @@ import { createOpenAI } from "@ai-sdk/openai"
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
 import { createOpenRouter, type LanguageModelV2 } from "@openrouter/ai-sdk-provider"
 import { createOpenaiCompatible as createGitHubCopilotOpenAICompatible } from "./sdk/copilot"
+import { createMock } from "./sdk/mock"
 import { createXai } from "@ai-sdk/xai"
 import { createMistral } from "@ai-sdk/mistral"
 import { createGroq } from "@ai-sdk/groq"
@@ -132,6 +133,7 @@ export namespace Provider {
     "gitlab-ai-provider": createGitLab,
     // @ts-ignore (TODO: kill this code so we dont have to maintain it)
     "@ai-sdk/github-copilot": createGitHubCopilotOpenAICompatible,
+    "@opencode/mock": createMock as any,
   }
 
   type CustomModelLoader = (sdk: any, modelID: string, options?: Record<string, any>) => Promise<any>
@@ -150,6 +152,11 @@ export namespace Provider {
   }
 
   const CUSTOM_LOADERS: Record<string, CustomLoader> = {
+    async mock() {
+      return {
+        autoload: true,
+      }
+    },
     async anthropic() {
       return {
         autoload: false,
@@ -920,6 +927,42 @@ export namespace Provider {
     const modelsDev = await ModelsDev.get()
     const database = mapValues(modelsDev, fromModelsDevProvider)
 
+    // Register the built-in mock provider for testing
+    database["mock"] = {
+      id: "mock",
+      name: "Mock",
+      source: "custom",
+      env: [],
+      options: {},
+      models: {
+        "mock-model": {
+          id: "mock-model",
+          providerID: "mock",
+          name: "Mock Model",
+          api: {
+            id: "mock-model",
+            url: "",
+            npm: "@opencode/mock",
+          },
+          status: "active",
+          capabilities: {
+            temperature: false,
+            reasoning: false,
+            attachment: false,
+            toolcall: true,
+            input: { text: true, audio: false, image: false, video: false, pdf: false },
+            output: { text: true, audio: false, image: false, video: false, pdf: false },
+            interleaved: false,
+          },
+          cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+          limit: { context: 128000, output: 4096 },
+          options: {},
+          headers: {},
+          release_date: "2025-01-01",
+        },
+      },
+    }
+
     const disabled = new Set(config.disabled_providers ?? [])
     const enabled = config.enabled_providers ? new Set(config.enabled_providers) : null
 
diff --git a/packages/opencode/src/provider/sdk/mock/PROTOCOL.md b/packages/opencode/src/provider/sdk/mock/PROTOCOL.md
new file mode 100644
index 0000000000..6a9c0b917f
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/PROTOCOL.md
@@ -0,0 +1,208 @@
+# Mock RPC
+
+Deterministic model scripting for tests.
+
+---
+
+## Overview
+
+The mock provider lets test harnesses script exactly what the model should emit. Instead of hitting a real API, the user message contains a JSON object that describes each step of the conversation. This makes test scenarios fully deterministic and reproducible.
+
+---
+
+## Understand the protocol
+
+The user message text is a JSON object with a `steps` array. Each step is an array of actions that the model emits on that turn.
+
+```json
+{
+  "steps": [
+    [{ "type": "text", "content": "Hello" }],
+    [{ "type": "text", "content": "Goodbye" }]
+  ]
+}
+```
+
+The mock model reads the **last** user message in the prompt to find this JSON.
+
+---
+
+## Know how steps are selected
+
+The model picks which step to execute by counting messages with `role: "tool"` in the prompt. This count represents how many tool-result rounds have occurred.
+
+- **Step 0** runs on the first call (no tool results yet).
+- **Step 1** runs after the first tool-result round.
+- **Step N** runs after the Nth tool-result round.
+
+If the step index is out of bounds, the model emits an empty set of actions.
+
+---
+
+## Use the `text` action
+
+Emits a text block.
+
+```json
+{ "type": "text", "content": "Some response text" }
+```
+
+| Field     | Type   | Description          |
+|-----------|--------|----------------------|
+| `content` | string | The text to emit.    |
+
+---
+
+## Use the `tool_call` action
+
+Calls a tool. The input object is passed as-is.
+
+```json
+{ "type": "tool_call", "name": "write", "input": { "filePath": "a.txt", "content": "hi" } }
+```
+
+| Field   | Type   | Description                     |
+|---------|--------|---------------------------------|
+| `name`  | string | Name of the tool to call.       |
+| `input` | object | Arguments passed to the tool.   |
+
+---
+
+## Use the `thinking` action
+
+Emits a reasoning/thinking block.
+
+```json
+{ "type": "thinking", "content": "Let me consider the options..." }
+```
+
+| Field     | Type   | Description                |
+|-----------|--------|----------------------------|
+| `content` | string | The thinking text to emit. |
+
+---
+
+## Use the `list_tools` action
+
+Responds with a JSON text block listing all available tools and their schemas. Useful for test scripts that need to discover tool names. No additional fields.
+
+```json
+{ "type": "list_tools" }
+```
+
+---
+
+## Use the `error` action
+
+Emits an error chunk.
+
+```json
+{ "type": "error", "message": "something went wrong" }
+```
+
+| Field     | Type   | Description            |
+|-----------|--------|------------------------|
+| `message` | string | The error message.     |
+
+---
+
+## Know the finish reason
+
+The finish reason is auto-inferred from the actions in the current step. If any action has `type: "tool_call"`, the finish reason is `"tool-calls"`. Otherwise it is `"stop"`.
+
+Token usage is always reported as `{ inputTokens: 10, outputTokens: 20, totalTokens: 30 }`.
+
+---
+
+## Handle invalid JSON
+
+If the user message is not valid JSON or doesn't have a `steps` array, the model falls back to a default text response. This keeps backward compatibility with tests that don't use the RPC protocol.
+
+---
+
+## Examples
+
+### Simple text response
+
+```json
+{
+  "steps": [
+    [{ "type": "text", "content": "Hello from the mock model" }]
+  ]
+}
+```
+
+### Tool discovery
+
+```json
+{
+  "steps": [
+    [{ "type": "list_tools" }]
+  ]
+}
+```
+
+### Single tool call
+
+```json
+{
+  "steps": [
+    [{ "type": "tool_call", "name": "read", "input": { "filePath": "config.json" } }]
+  ]
+}
+```
+
+### Multi-turn tool use
+
+Step 0 calls a tool. Step 1 runs after the tool result comes back and emits a text response.
+
+```json
+{
+  "steps": [
+    [{ "type": "tool_call", "name": "write", "input": { "filePath": "a.txt", "content": "hi" } }],
+    [{ "type": "text", "content": "Done writing the file." }]
+  ]
+}
+```
+
+### Thinking and text
+
+```json
+{
+  "steps": [
+    [
+      { "type": "thinking", "content": "The user wants a greeting." },
+      { "type": "text", "content": "Hey there!" }
+    ]
+  ]
+}
+```
+
+### Multiple actions in one step
+
+A single step can contain any combination of actions.
+
+```json
+{
+  "steps": [
+    [
+      { "type": "text", "content": "I'll create two files." },
+      { "type": "tool_call", "name": "write", "input": { "filePath": "a.txt", "content": "aaa" } },
+      { "type": "tool_call", "name": "write", "input": { "filePath": "b.txt", "content": "bbb" } }
+    ],
+    [
+      { "type": "text", "content": "Both files created." }
+    ]
+  ]
+}
+```
+
+### Error simulation
+
+```json
+{
+  "steps": [
+    [{ "type": "error", "message": "rate limit exceeded" }]
+  ]
+}
+```
diff --git a/packages/opencode/src/provider/sdk/mock/README.md b/packages/opencode/src/provider/sdk/mock/README.md
new file mode 100644
index 0000000000..4808dd3e14
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/README.md
@@ -0,0 +1,19 @@
+I got it to the point where it can run a full mock session
+
+Run the server with `./src/provider/sdk/mock/run`. It will run it sandboxes to make sure it doesn't interact with the outside world unexpectedly.
+
+Then run `bun run src/provider/sdk/mock/runner/index.ts` to drive a session and get a log
+
+There is also `bun run src/provider/sdk/mock/runner/diff.ts` which will drive two sessions at once and compare them. This is annoying right now because you have to run two servers. This would let you compare the differences between versions though
+
+## Coverage
+
+I also have an experiment in `serve.test.ts` which runs the server as a bun test, which gives us access to coverage info. Run it like this:
+
+```
+bun test --coverage --coverage-reporter=lcov --timeout 0 src/provider/sdk/mock/runner/serve.test.ts
+```
+
+That will give you a `lcov.info` file. Convert it to HTML with this:
+
+genhtml coverage/lcov.info -o coverage/html && open coverage/html/index.html
\ No newline at end of file
diff --git a/packages/opencode/src/provider/sdk/mock/index.ts b/packages/opencode/src/provider/sdk/mock/index.ts
new file mode 100644
index 0000000000..4f68e4c353
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/index.ts
@@ -0,0 +1,24 @@
+import type { LanguageModelV2 } from "@ai-sdk/provider"
+import { MockLanguageModel } from "./model"
+
+export { vfsPlugin } from "./plugin"
+export { Filesystem as VFilesystem } from "./vfs"
+
+export interface MockProviderSettings {
+  name?: string
+}
+
+export interface MockProvider {
+  (id: string): LanguageModelV2
+  languageModel(id: string): LanguageModelV2
+}
+
+export function createMock(options: MockProviderSettings = {}): MockProvider {
+  const name = options.name ?? "mock"
+
+  const create = (id: string) => new MockLanguageModel(id, { provider: name })
+
+  const provider = Object.assign((id: string) => create(id), { languageModel: create })
+
+  return provider
+}
diff --git a/packages/opencode/src/provider/sdk/mock/model.ts b/packages/opencode/src/provider/sdk/mock/model.ts
new file mode 100644
index 0000000000..efd70abfae
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/model.ts
@@ -0,0 +1,244 @@
+import type {
+  LanguageModelV2,
+  LanguageModelV2CallOptions,
+  LanguageModelV2FunctionTool,
+  LanguageModelV2StreamPart,
+} from "@ai-sdk/provider"
+
+/**
+ * Mock Model RPC Protocol
+ *
+ * The user message text is a JSON object that scripts exactly what the mock
+ * model should emit. This lets test harnesses drive the model deterministically.
+ *
+ * Schema:
+ * ```
+ * {
+ *   "steps": [
+ *     // Step 0: executed on first call (no tool results yet)
+ *     [
+ *       { "type": "tool_call", "name": "write", "input": { "filePath": "a.txt", "content": "hi" } }
+ *     ],
+ *     // Step 1: executed after first tool-result round
+ *     [
+ *       { "type": "text", "content": "Done!" }
+ *     ]
+ *   ]
+ * }
+ * ```
+ *
+ * Supported actions:
+ *
+ *   { "type": "text", "content": "string" }
+ *     Emit a text block.
+ *
+ *   { "type": "tool_call", "name": "toolName", "input": { ... } }
+ *     Call a tool. The input object is passed as-is.
+ *
+ *   { "type": "thinking", "content": "string" }
+ *     Emit a reasoning/thinking block.
+ *
+ *   { "type": "list_tools" }
+ *     Respond with a JSON text block listing all available tools and their
+ *     schemas. Useful for test scripts that need to discover tool names.
+ *
+ *   { "type": "error", "message": "string" }
+ *     Emit an error chunk.
+ *
+ * Finish reason is auto-inferred: "tool-calls" when any tool_call action
+ * exists in the step, "stop" otherwise. Override with a top-level "finish"
+ * field on the script object.
+ *
+ * If the user message is not valid JSON or doesn't match the schema, the
+ * model falls back to a default text response (backward compatible).
+ */
+
+// ── Protocol types ──────────────────────────────────────────────────────
+
+type TextAction = { type: "text"; content: string }
+type ToolCallAction = { type: "tool_call"; name: string; input: Record<string, unknown> }
+type ThinkingAction = { type: "thinking"; content: string }
+type ListToolsAction = { type: "list_tools" }
+type ErrorAction = { type: "error"; message: string }
+
+type Action = TextAction | ToolCallAction | ThinkingAction | ListToolsAction | ErrorAction
+
+type Script = {
+  steps: Action[][]
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────
+
+function text(options: LanguageModelV2CallOptions): string {
+  for (const msg of [...options.prompt].reverse()) {
+    if (msg.role !== "user") continue
+    for (const part of msg.content) {
+      if (part.type === "text") return part.text
+    }
+  }
+  return ""
+}
+
+/** Count tool-result rounds since the last user message. */
+function round(options: LanguageModelV2CallOptions): number {
+  let count = 0
+  for (const msg of [...options.prompt].reverse()) {
+    if (msg.role === "user") break
+    if (msg.role === "tool") count++
+  }
+  return count
+}
+
+function parse(raw: string): Script | undefined {
+  try {
+    const json = JSON.parse(raw)
+    if (!json || !Array.isArray(json.steps)) return undefined
+    return json as Script
+  } catch {
+    return undefined
+  }
+}
+
+function tools(options: LanguageModelV2CallOptions): LanguageModelV2FunctionTool[] {
+  if (!options.tools) return []
+  return options.tools.filter((t): t is LanguageModelV2FunctionTool => t.type === "function")
+}
+
+function emit(actions: Action[], options: LanguageModelV2CallOptions): LanguageModelV2StreamPart[] {
+  const chunks: LanguageModelV2StreamPart[] = []
+  let tid = 0
+  let rid = 0
+  let xid = 0
+
+  for (const action of actions) {
+    switch (action.type) {
+      case "text": {
+        const id = `mock-text-${xid++}`
+        chunks.push(
+          { type: "text-start", id },
+          { type: "text-delta", id, delta: action.content },
+          { type: "text-end", id },
+        )
+        break
+      }
+
+      case "tool_call": {
+        const id = `mock-call-${tid++}`
+        const input = JSON.stringify(action.input)
+        chunks.push(
+          { type: "tool-input-start", id, toolName: action.name },
+          { type: "tool-input-delta", id, delta: input },
+          { type: "tool-input-end", id },
+          { type: "tool-call" as const, toolCallId: id, toolName: action.name, input },
+        )
+        break
+      }
+
+      case "thinking": {
+        const id = `mock-reasoning-${rid++}`
+        chunks.push(
+          { type: "reasoning-start", id },
+          { type: "reasoning-delta", id, delta: action.content },
+          { type: "reasoning-end", id },
+        )
+        break
+      }
+
+      case "list_tools": {
+        const id = `mock-text-${xid++}`
+        const defs = tools(options).map((t) => ({
+          name: t.name,
+          description: t.description,
+          input: t.inputSchema,
+        }))
+        chunks.push(
+          { type: "text-start", id },
+          { type: "text-delta", id, delta: JSON.stringify(defs, null, 2) },
+          { type: "text-end", id },
+        )
+        break
+      }
+
+      case "error": {
+        chunks.push({ type: "error", error: new Error(action.message) })
+        break
+      }
+    }
+  }
+
+  return chunks
+}
+
+// ── Model ───────────────────────────────────────────────────────────────
+
+export class MockLanguageModel implements LanguageModelV2 {
+  readonly specificationVersion = "v2" as const
+  readonly provider: string
+  readonly modelId: string
+  readonly supportedUrls: Record<string, RegExp[]> = {}
+
+  constructor(
+    id: string,
+    readonly options: { provider: string },
+  ) {
+    this.modelId = id
+    this.provider = options.provider
+  }
+
+  async doGenerate(options: LanguageModelV2CallOptions): Promise<never> {
+    throw new Error("`doGenerate` not implemented")
+  }
+
+  async doStream(options: LanguageModelV2CallOptions) {
+    const raw = text(options)
+    const script = parse(raw)
+    const r = round(options)
+    const actions = script ? (script.steps[r] ?? []) : undefined
+
+    const chunks: LanguageModelV2StreamPart[] = [
+      { type: "stream-start", warnings: [] },
+      {
+        type: "response-metadata",
+        id: "mock-response",
+        modelId: this.modelId,
+        timestamp: new Date(),
+      },
+    ]
+
+    if (actions) {
+      chunks.push(...emit(actions, options))
+    } else {
+      // Fallback: plain text response (backward compatible)
+      chunks.push(
+        { type: "text-start", id: "mock-text-0" },
+        {
+          type: "text-delta",
+          id: "mock-text-0",
+          delta: `[mock] This is a streamed mock response from model "${this.modelId}". `,
+        },
+        {
+          type: "text-delta",
+          id: "mock-text-0",
+          delta: "The mock provider does not call any real API.",
+        },
+        { type: "text-end", id: "mock-text-0" },
+      )
+    }
+
+    const called = actions?.some((a) => a.type === "tool_call")
+    chunks.push({
+      type: "finish",
+      finishReason: called ? "tool-calls" : "stop",
+      usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 },
+    })
+
+    const stream = new ReadableStream<LanguageModelV2StreamPart>({
+      start(controller) {
+        for (const chunk of chunks) controller.enqueue(chunk)
+        controller.close()
+      },
+    })
+
+    return { stream }
+  }
+}
diff --git a/packages/opencode/src/provider/sdk/mock/plugin.ts b/packages/opencode/src/provider/sdk/mock/plugin.ts
new file mode 100644
index 0000000000..0c8607ba8a
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/plugin.ts
@@ -0,0 +1,18 @@
+import type { BunPlugin } from "bun"
+import { Filesystem } from "./vfs"
+
+/**
+ * Bun plugin that intercepts all loads of `util/filesystem.ts` and replaces
+ * the real Filesystem namespace with the in-memory VFS implementation.
+ *
+ * Must be registered via preload before any application code runs.
+ */
+export const vfsPlugin: BunPlugin = {
+  name: "vfs",
+  setup(build) {
+    build.onLoad({ filter: /util\/filesystem\.ts$/ }, () => ({
+      exports: { Filesystem },
+      loader: "object",
+    }))
+  },
+}
diff --git a/packages/opencode/src/provider/sdk/mock/preload.ts b/packages/opencode/src/provider/sdk/mock/preload.ts
new file mode 100644
index 0000000000..638bd480de
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/preload.ts
@@ -0,0 +1,2 @@
+import { vfsPlugin } from "./plugin"
+Bun.plugin(vfsPlugin)
diff --git a/packages/opencode/src/provider/sdk/mock/run b/packages/opencode/src/provider/sdk/mock/run
new file mode 100755
index 0000000000..42da9a12b7
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/run
@@ -0,0 +1,6 @@
+#!/bin/sh
+
+ROOT="$(dirname "$0")"
+
+cd "$ROOT/../../../.."
+sandbox-exec -f ./src/provider/sdk/mock/sandbox.sb -D HOME=$HOME bun --preload  "$ROOT/preload.ts" "src/index.ts" serve
\ No newline at end of file
diff --git a/packages/opencode/src/provider/sdk/mock/runner/core.ts b/packages/opencode/src/provider/sdk/mock/runner/core.ts
new file mode 100644
index 0000000000..03d76b1a95
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/runner/core.ts
@@ -0,0 +1,346 @@
+/**
+ * Shared core for mock runners: HTTP, SSE, script generation, message handling.
+ */
+
+import path from "path"
+
+// ── Types ───────────────────────────────────────────────────────────────
+
+export type Tool = {
+  id: string
+  description: string
+  parameters: {
+    type: string
+    properties?: Record<string, { type: string; description?: string }>
+    required?: string[]
+  }
+}
+
+export type Action =
+  | { type: "text"; content: string }
+  | { type: "tool_call"; name: string; input: Record<string, unknown> }
+  | { type: "thinking"; content: string }
+  | { type: "list_tools" }
+  | { type: "error"; message: string }
+
+export type Script = { steps: Action[][] }
+export type Event = { type: string; properties: Record<string, any> }
+export type Message = { info: Record<string, any>; parts: Record<string, any>[] }
+type Listener = (event: Event) => void
+
+export type Instance = {
+  name: string
+  base: string
+  sse: AbortController
+}
+
+// ── HTTP ────────────────────────────────────────────────────────────────
+
+export async function api<T = unknown>(base: string, method: string, path: string, body?: unknown): Promise<T> {
+  const opts: RequestInit = {
+    method,
+    headers: { "Content-Type": "application/json" },
+  }
+  if (body !== undefined) opts.body = JSON.stringify(body)
+  const res = await fetch(`${base}${path}`, opts)
+  if (!res.ok) {
+    const text = await res.text().catch(() => "")
+    throw new Error(`${method} ${path} → ${res.status}: ${text}`)
+  }
+  if (res.status === 204) return undefined as T
+  return res.json() as T
+}
+
+// ── SSE ─────────────────────────────────────────────────────────────────
+
+const listeners = new Map<AbortController, Listener>()
+
+function subscribe(base: string, cb: Listener): AbortController {
+  const abort = new AbortController()
+  ;(async () => {
+    const res = await fetch(`${base}/event`, {
+      headers: { Accept: "text/event-stream" },
+      signal: abort.signal,
+    })
+    if (!res.ok || !res.body) {
+      log("SSE connect failed", base, res.status)
+      return
+    }
+    const reader = res.body.getReader()
+    const decoder = new TextDecoder()
+    let buf = ""
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      buf += decoder.decode(value, { stream: true })
+      const lines = buf.split("\n")
+      buf = lines.pop()!
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue
+        try {
+          cb(JSON.parse(line.slice(6)))
+        } catch {}
+      }
+    }
+  })().catch(() => {})
+  return abort
+}
+
+export function startSSE(base: string): AbortController {
+  const ctrl = subscribe(base, (evt) => {
+    const fn = listeners.get(ctrl)
+    fn?.(evt)
+  })
+  listeners.set(ctrl, () => {})
+  return ctrl
+}
+
+export function idle(sid: string, sse: AbortController, timeout = 60_000): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      cleanup()
+      reject(new Error(`session ${sid} did not become idle within ${timeout}ms`))
+    }, timeout)
+
+    const orig = listeners.get(sse)
+    const handler = (evt: Event) => {
+      orig?.(evt)
+      if (evt.type !== "session.status") return
+      if (evt.properties.sessionID !== sid) return
+      if (evt.properties.status?.type === "idle") {
+        cleanup()
+        resolve()
+      }
+    }
+    listeners.set(sse, handler)
+
+    function cleanup() {
+      clearTimeout(timer)
+      if (orig) listeners.set(sse, orig)
+    }
+  })
+}
+
+// ── Tool discovery ──────────────────────────────────────────────────────
+
+let cachedTools: Tool[] | undefined
+
+export async function tools(base: string): Promise<Tool[]> {
+  if (cachedTools) return cachedTools
+  cachedTools = await api<Tool[]>(base, "GET", "/experimental/tool?provider=mock&model=mock-model")
+  return cachedTools
+}
+
+// ── Random generators ───────────────────────────────────────────────────
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)]
+}
+
+export function rand(min: number, max: number) {
+  return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+const WORDS = [
+  "foo",
+  "bar",
+  "baz",
+  "qux",
+  "hello",
+  "world",
+  "test",
+  "alpha",
+  "beta",
+  "gamma",
+  "delta",
+  "src",
+  "lib",
+  "tmp",
+]
+const EXTS = [".ts", ".js", ".json", ".txt", ".md"]
+
+function word() {
+  return pick(WORDS)
+}
+
+function sentence() {
+  const n = rand(3, 12)
+  return Array.from({ length: n }, () => word()).join(" ")
+}
+
+function filepath() {
+  const depth = rand(1, 3)
+  const parts = Array.from({ length: depth }, () => word())
+  return parts.join("/") + pick(EXTS)
+}
+
+function fakeInput(tool: Tool): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+  const props = tool.parameters.properties ?? {}
+  for (const [key, schema] of Object.entries(props)) {
+    switch (schema.type) {
+      case "string":
+        if (key.toLowerCase().includes("path") || key.toLowerCase().includes("file")) {
+          result[key] = filepath()
+        } else if (key.toLowerCase().includes("pattern") || key.toLowerCase().includes("regex")) {
+          result[key] = word()
+        } else if (key.toLowerCase().includes("command") || key.toLowerCase().includes("cmd")) {
+          result[key] = `echo ${word()}`
+        } else {
+          result[key] = sentence()
+        }
+        break
+      case "number":
+      case "integer":
+        result[key] = rand(1, 100)
+        break
+      case "boolean":
+        result[key] = Math.random() > 0.5
+        break
+      case "object":
+        result[key] = {}
+        break
+      case "array":
+        result[key] = []
+        break
+      default:
+        result[key] = sentence()
+    }
+  }
+  return result
+}
+
+// ── Action generators ───────────────────────────────────────────────────
+
+const SAFE_TOOLS = new Set(["read", "glob", "grep", "todowrite", "webfetch", "websearch", "codesearch"])
+const WRITE_TOOLS = new Set(["write", "edit", "bash"])
+
+function textAction(): Action {
+  return { type: "text", content: sentence() }
+}
+
+function thinkingAction(): Action {
+  return { type: "thinking", content: sentence() }
+}
+
+function errorAction(): Action {
+  return { type: "error", message: `mock error: ${word()}` }
+}
+
+function listToolsAction(): Action {
+  return { type: "list_tools" }
+}
+
+async function toolAction(base: string): Promise<Action> {
+  const all = await tools(base)
+  const safe = all.filter((t) => SAFE_TOOLS.has(t.id) || WRITE_TOOLS.has(t.id))
+  if (!safe.length) return textAction()
+  const tool = pick(safe)
+  return { type: "tool_call", name: tool.id, input: fakeInput(tool) }
+}
+
+// ── Script generation ───────────────────────────────────────────────────
+
+export async function script(base: string): Promise<Script> {
+  const r = Math.random()
+
+  if (r < 0.4) {
+    const call = await toolAction(base)
+    return { steps: [[call], [textAction()]] }
+  }
+  if (r < 0.6) {
+    return { steps: [[thinkingAction(), textAction()]] }
+  }
+  if (r < 0.75) {
+    const n = rand(2, 4)
+    const calls: Action[] = []
+    for (let i = 0; i < n; i++) calls.push(await toolAction(base))
+    return { steps: [calls, [textAction()]] }
+  }
+  if (r < 0.85) {
+    return { steps: [[textAction()]] }
+  }
+  if (r < 0.9) {
+    return { steps: [[listToolsAction()]] }
+  }
+  if (r < 0.95) {
+    const call = await toolAction(base)
+    return { steps: [[thinkingAction(), call], [textAction()]] }
+  }
+  return { steps: [[errorAction()]] }
+}
+
+// ── Pre-generate all scripts for a session ──────────────────────────────
+
+export async function generate(base: string, count: number): Promise<Script[]> {
+  const scripts: Script[] = []
+  for (let i = 0; i < count; i++) scripts.push(await script(base))
+  return scripts
+}
+
+// ── Messages ────────────────────────────────────────────────────────────
+
+export async function messages(base: string, sid: string): Promise<Message[]> {
+  return api<Message[]>(base, "GET", `/session/${sid}/message`)
+}
+
+// ── Run a full session: send all scripts, return all messages ───────────
+
+export async function run(inst: Instance, scripts: Script[]): Promise<Message[]> {
+  const info = await api<{ id: string }>(inst.base, "POST", "/session", {})
+  const sid = info.id
+
+  for (const s of scripts) {
+    const payload = JSON.stringify(s)
+    const wait = idle(sid, inst.sse)
+    await api(inst.base, "POST", `/session/${sid}/prompt_async`, {
+      parts: [{ type: "text", text: payload }],
+      model: { providerID: "mock", modelID: "mock-model" },
+    })
+    await wait
+  }
+
+  return messages(inst.base, sid)
+}
+
+// ── Connect to an instance ──────────────────────────────────────────────
+
+export async function connect(name: string, port: string): Promise<Instance> {
+  const base = `http://localhost:${port}`
+  const health = await api<{ healthy: boolean; version: string }>(base, "GET", "/global/health")
+  if (!health.healthy) throw new Error(`${name} not healthy`)
+  log(`${name}: version ${health.version} at ${base}`)
+  const sse = startSSE(base)
+  return { name, base, sse }
+}
+
+// ── Logging ─────────────────────────────────────────────────────────────
+
+export function log(...args: unknown[]) {
+  const ts = new Date().toISOString().slice(11, 23)
+  console.log(`[${ts}]`, ...args)
+}
+
+export function summary(s: Script): string {
+  const actions = s.steps.flat()
+  const types = actions.map((a) => {
+    if (a.type === "tool_call") return `tool:${a.name}`
+    return a.type
+  })
+  return `${s.steps.length} step(s): ${types.join(", ")}`
+}
+
+export function logMessages(msgs: Message[]) {
+  for (const msg of msgs) {
+    const role = msg.info.role
+    const parts = msg.parts.map((p: any) => {
+      if (p.type === "text") return `text: ${p.text?.slice(0, 80)}${p.text?.length > 80 ? "..." : ""}`
+      if (p.type === "tool") return `tool:${p.tool}(${p.state?.status})`
+      if (p.type === "reasoning") return `reasoning: ${p.text?.slice(0, 60)}${(p.text?.length ?? 0) > 60 ? "..." : ""}`
+      if (p.type === "step-start") return "step-start"
+      if (p.type === "step-finish") return `step-finish(${p.reason})`
+      return p.type
+    })
+    log(`    ${role} [${msg.info.id?.slice(0, 8)}] ${parts.join(" | ")}`)
+  }
+}
diff --git a/packages/opencode/src/provider/sdk/mock/runner/diff.ts b/packages/opencode/src/provider/sdk/mock/runner/diff.ts
new file mode 100644
index 0000000000..f7bea3e410
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/runner/diff.ts
@@ -0,0 +1,130 @@
+/**
+ * Mock Runner — Dual Instance Diff
+ *
+ * Connects to TWO running opencode servers, runs identical mock RPC scripts
+ * against both (all turns on A, then all turns on B), and diffs the results.
+ * Each session run writes the full serialized messages and a unified diff
+ * into a folder under ./errors/<id>/.
+ *
+ * Usage:
+ *   bun run src/provider/sdk/mock/runner/diff.ts <port1> <port2>
+ */
+
+import path from "path"
+import { connect, generate, run, log, summary, tools, rand, type Message } from "./core"
+
+const port1 = process.argv[2]
+const port2 = process.argv[3]
+
+if (!port1 || !port2) {
+  console.error("Usage: bun run src/provider/sdk/mock/runner/diff.ts <port1> <port2>")
+  process.exit(1)
+}
+
+const ERRORS_DIR = path.join(import.meta.dir, "errors")
+
+// ── Normalize ───────────────────────────────────────────────────────────
+
+function normalize(msgs: Message[]): object[] {
+  return msgs.map((m) => ({
+    role: m.info.role,
+    parts: m.parts.map((p) => {
+      const { id, sessionID, messageID, ...rest } = p
+      if (rest.type === "tool" && rest.state) {
+        const { time, ...state } = rest.state
+        return { ...rest, state }
+      }
+      if (rest.type === "step-finish") {
+        const { cost, tokens, ...finish } = rest
+        return finish
+      }
+      if ("time" in rest) {
+        const { time, ...without } = rest
+        return without
+      }
+      return rest
+    }),
+  }))
+}
+
+// ── Write results ───────────────────────────────────────────────────────
+
+async function writeResults(scripts: { steps: object[][] }[], a: Message[], b: Message[]): Promise<string | false> {
+  const na = normalize(a)
+  const nb = normalize(b)
+  const ja = JSON.stringify(na, null, 2)
+  const jb = JSON.stringify(nb, null, 2)
+
+  if (ja === jb) return false
+
+  const id = Math.random().toString(36).slice(2, 10)
+  const dir = path.join(ERRORS_DIR, id)
+
+  const fileA = path.join(dir, "normalized_a.json")
+  const fileB = path.join(dir, "normalized_b.json")
+
+  await Promise.all([
+    Bun.write(path.join(dir, "messages_a.json"), JSON.stringify(a, null, 2)),
+    Bun.write(path.join(dir, "messages_b.json"), JSON.stringify(b, null, 2)),
+    Bun.write(fileA, ja),
+    Bun.write(fileB, jb),
+  ])
+
+  // generate unified diff via system `diff`
+  const proc = Bun.spawn(["diff", "-u", "--label", "instance_a", fileA, "--label", "instance_b", fileB], {
+    stdout: "pipe",
+  })
+  const patch = await new Response(proc.stdout).text()
+  await proc.exited
+  await Bun.write(path.join(dir, "diff.patch"), patch)
+
+  return dir
+}
+
+// ── Session loop ────────────────────────────────────────────────────────
+
+async function session(a: Awaited<ReturnType<typeof connect>>, b: Awaited<ReturnType<typeof connect>>) {
+  const turns = rand(30, 100)
+  const scripts = await generate(a.base, turns)
+
+  log(`${turns} turns generated: ${scripts.map((s) => summary(s)).join(", ")}`)
+
+  log(`running ${turns} turns on A...`)
+  const msgsA = await run(a, scripts)
+  log(`A: ${msgsA.length} messages`)
+
+  log(`running ${turns} turns on B...`)
+  const msgsB = await run(b, scripts)
+  log(`B: ${msgsB.length} messages`)
+
+  const dir = await writeResults(scripts, msgsA, msgsB)
+  if (dir) {
+    log(`DIFF → ${dir}`)
+  } else {
+    log(`OK — no differences`)
+  }
+}
+
+// ── Main ────────────────────────────────────────────────────────────────
+
+async function main() {
+  const a = await connect("A", port1)
+  const b = await connect("B", port2)
+
+  const t = await tools(a.base)
+  log(`${t.length} tools: ${t.map((x) => x.id).join(", ")}`)
+
+  while (true) {
+    try {
+      await session(a, b)
+    } catch (e: any) {
+      log(`session failed: ${e.message}`)
+      await Bun.sleep(2000)
+    }
+  }
+}
+
+main().catch((e) => {
+  console.error(e)
+  process.exit(1)
+})
diff --git a/packages/opencode/src/provider/sdk/mock/runner/index.ts b/packages/opencode/src/provider/sdk/mock/runner/index.ts
new file mode 100644
index 0000000000..304f326ea1
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/runner/index.ts
@@ -0,0 +1,89 @@
+/**
+ * Mock Runner — Single Instance (Log Mode)
+ *
+ * Connects to one running opencode server, sends mock RPC scripts,
+ * and logs all user/assistant messages per turn.
+ *
+ * Usage:
+ *   bun run src/provider/sdk/mock/runner/index.ts <port>
+ */
+
+import {
+  connect,
+  generate,
+  run,
+  log,
+  summary,
+  logMessages,
+  tools,
+  rand,
+  api,
+  idle,
+  messages,
+  type Message,
+} from "./core"
+
+const port = process.argv[2] ?? "4096"
+
+async function session(inst: Awaited<ReturnType<typeof connect>>) {
+  const info = await api<{ id: string }>(inst.base, "POST", "/session", {})
+  const sid = info.id
+  const turns = rand(30, 100)
+  const history: Message[] = []
+
+  log(`session ${sid} — ${turns} turns`)
+
+  const scripts = await generate(inst.base, turns)
+
+  for (let i = 0; i < scripts.length; i++) {
+    const s = scripts[i]
+    const payload = JSON.stringify(s)
+    log(`  [${i + 1}/${turns}] ${summary(s)}`)
+
+    try {
+      const wait = idle(sid, inst.sse)
+      await api(inst.base, "POST", `/session/${sid}/prompt_async`, {
+        parts: [{ type: "text", text: payload }],
+        model: { providerID: "mock", modelID: "mock-model" },
+      })
+      await wait
+
+      const all = await messages(inst.base, sid)
+      const known = new Set(history.map((m) => m.info.id))
+      const fresh = all.filter((m) => !known.has(m.info.id))
+
+      log(`  → ${fresh.length} new message(s):`)
+      logMessages(fresh)
+
+      history.push(...fresh)
+    } catch (e: any) {
+      log(`  error on turn ${i + 1}: ${e.message}`)
+      await Bun.sleep(1000)
+      await api(inst.base, "POST", `/session/${sid}/abort`).catch(() => {})
+      await Bun.sleep(500)
+    }
+  }
+
+  log(`session ${sid} — done (${history.length} messages total)`)
+}
+
+async function main() {
+  const inst = await connect("server", port)
+
+  const t = await tools(inst.base)
+  log(`${t.length} tools: ${t.map((x) => x.id).join(", ")}`)
+
+  while (true) {
+    try {
+      await session(inst)
+    } catch (e: any) {
+      log(`session failed: ${e.message}`)
+      await Bun.sleep(2000)
+    }
+  }
+}
+
+main().catch((e) => {
+  console.error(e)
+  process.exit(1)
+})
diff --git a/packages/opencode/src/provider/sdk/mock/runner/serve.test.ts b/packages/opencode/src/provider/sdk/mock/runner/serve.test.ts
new file mode 100644
index 0000000000..b9c3ad8072
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/runner/serve.test.ts
@@ -0,0 +1,52 @@
+import { vfsPlugin } from "../plugin"
+Bun.plugin(vfsPlugin)
+
+/**
+ * Starts the mock opencode server inside bun:test so coverage instrumentation works.
+ *
+ * Usage:
+ *   bun test --coverage --coverage-reporter=lcov --timeout 0 src/provider/sdk/mock/runner/serve.test.ts
+ *
+ * The server runs until the process is killed (Ctrl-C).
+ * Coverage data is flushed on exit.
+ */
+
+import { test } from "bun:test"
+import { Log } from "../../../../util/log"
+import { Server } from "../../../../server/server"
+import { Global } from "../../../../global"
+import { Filesystem } from "../../../../util/filesystem"
+import { JsonMigration } from "../../../../storage/json-migration"
+import { Database } from "../../../../storage/db"
+import path from "path"
+
+const PORT = 4096;
+
+test("serve", async () => {
+  process.env.AGENT = "1"
+  process.env.OPENCODE = "1"
+  process.env.OPENCODE_PID = String(process.pid)
+
+  await Log.init({ print: false, dev: true, level: "DEBUG" })
+
+  const marker = path.join(Global.Path.data, "opencode.db")
+  if (!(await Filesystem.exists(marker))) {
+    console.log("Running one-time database migration...")
+    await JsonMigration.run(Database.Client().$client, {
+      progress: (event) => {
+        const pct = Math.floor((event.current / event.total) * 100)
+        if (event.current === event.total || pct % 25 === 0) {
+          console.log(`  migration: ${pct}%`)
+        }
+      },
+    })
+    console.log("Migration complete.")
+  }
+
+  const server = Server.listen({ port: PORT, hostname: "127.0.0.1" })
+  console.log(`opencode server listening on http://${server.hostname}:${server.port}`)
+
+  // keep alive until killed
+  await new Promise(() => {})
+  await server.stop()
+})
diff --git a/packages/opencode/src/provider/sdk/mock/sandbox.sb b/packages/opencode/src/provider/sdk/mock/sandbox.sb
new file mode 100644
index 0000000000..613bfab7d1
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/sandbox.sb
@@ -0,0 +1,17 @@
+(version 1)
+
+;; Start permissive, then lock down network and filesystem
+(allow default)
+
+;; ── Network: deny all, allow localhost ──
+(deny network*)
+(allow network* (local ip "localhost:*"))
+(allow network* (remote ip "localhost:*"))
+
+;; ── Filesystem writes: deny all, then allow temp dirs ──
+(deny file-write*)
+
+;; ── Filesystem reads: deny sensitive dirs ──
+(deny file-read*
+  (subpath (string-append (param "HOME") "/.local"))
+  (subpath (string-append (param "HOME") "/.config")))
diff --git a/packages/opencode/src/provider/sdk/mock/vfs.ts b/packages/opencode/src/provider/sdk/mock/vfs.ts
new file mode 100644
index 0000000000..404f795292
--- /dev/null
+++ b/packages/opencode/src/provider/sdk/mock/vfs.ts
@@ -0,0 +1,243 @@
+import path from "path"
+import { lookup } from "mime-types"
+
+const ROOT = '/mock'
+
+// TODO:
+//
+// * Some places use the `glob` utility to scan the filesystem which
+//   does not go through `Filesystem`. We should mock that too
+
+function globToRegex(pattern: string, cwd: string): RegExp {
+  const full = pattern.startsWith("/") ? pattern : cwd.replace(/\/$/, "") + "/" + pattern
+  const escaped = full
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*\*/g, "<<<GLOBSTAR>>>")
+    .replace(/\*/g, "[^/]*")
+    .replace(/<<<GLOBSTAR>>>/g, ".*")
+    .replace(/\?/g, "[^/]")
+  return new RegExp("^" + escaped + "$")
+}
+
+function enoent(p: string) {
+  return Object.assign(new Error(`ENOENT: ${p}`), { code: "ENOENT" })
+}
+
+/**
+ * In-memory virtual filesystem that implements the same API as the
+ * real `Filesystem` namespace from `util/filesystem`.
+ */
+export namespace Filesystem {
+  const files = new Map<string, string>()
+
+  // seed
+  // for (const [p, content] of Object.entries(SEED)) {
+  //   files.set(p, content)
+  // }
+
+  function abs(p: string) {
+    if (!path.isAbsolute(p)) return path.join(ROOT, p)
+    return p
+  }
+
+  function pfx(p: string) {
+    const resolved = abs(p)
+    return resolved.endsWith("/") ? resolved : resolved + "/"
+  }
+
+  // -- Filesystem API --
+
+  export async function exists(p: string) {
+    const resolved = abs(p)
+    if (files.has(resolved)) return true
+    const pre = pfx(p)
+    for (const key of files.keys()) {
+      if (key.startsWith(pre)) return true
+    }
+    return false
+  }
+
+  export async function isDir(p: string) {
+    const resolved = abs(p)
+    if (files.has(resolved)) return false
+    const pre = pfx(p)
+    for (const key of files.keys()) {
+      if (key.startsWith(pre)) return true
+    }
+    return false
+  }
+
+  export function stat(p: string) {
+    const resolved = abs(p)
+    const content = files.get(resolved)
+    if (content !== undefined) {
+      const sz = new TextEncoder().encode(content).byteLength
+      return {
+        isFile: () => true,
+        isDirectory: () => false,
+        isSymbolicLink: () => false,
+        size: sz,
+        mtimeMs: Date.now(),
+        mtime: new Date(),
+      }
+    }
+    // check directory
+    const pre = pfx(p)
+    for (const key of files.keys()) {
+      if (key.startsWith(pre)) {
+        return {
+          isFile: () => false,
+          isDirectory: () => true,
+          isSymbolicLink: () => false,
+          size: 0,
+          mtimeMs: Date.now(),
+          mtime: new Date(),
+        }
+      }
+    }
+    return undefined
+  }
+
+  export async function size(p: string) {
+    const content = files.get(abs(p))
+    if (content === undefined) return 0
+    return new TextEncoder().encode(content).byteLength
+  }
+
+  export async function readText(p: string) {
+    console.log('reading', p)
+    const content = files.get(abs(p))
+    if (content === undefined) throw enoent(p)
+    return content
+  }
+
+  export async function readJson<T = any>(p: string): Promise<T> {
+    console.log('reading', p)
+    const content = files.get(abs(p))
+    if (content === undefined) throw enoent(p)
+    return JSON.parse(content)
+  }
+
+  export async function readBytes(p: string) {
+    console.log('reading', p)
+    const content = files.get(abs(p))
+    if (content === undefined) throw enoent(p)
+    return Buffer.from(content)
+  }
+
+  export async function readArrayBuffer(p: string) {
+    const content = files.get(abs(p))
+    if (content === undefined) throw enoent(p)
+    const buf = Buffer.from(content)
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength) as ArrayBuffer
+  }
+
+  export async function write(p: string, content: string | Buffer | Uint8Array, _mode?: number) {
+    console.log('writing', p)
+    files.set(abs(p), typeof content === "string" ? content : Buffer.from(content).toString("utf-8"))
+  }
+
+  export async function writeJson(p: string, data: unknown, _mode?: number) {
+    files.set(abs(p), JSON.stringify(data, null, 2))
+  }
+
+  export async function writeStream(p: string, stream: ReadableStream<Uint8Array>, _mode?: number) {
+    const reader = stream.getReader()
+    const chunks: Uint8Array[] = []
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      chunks.push(value)
+    }
+    files.set(abs(p), Buffer.concat(chunks).toString("utf-8"))
+  }
+
+  export function mimeType(p: string) {
+    return lookup(p) || "application/octet-stream"
+  }
+
+  export function normalizePath(p: string) {
+    return p
+  }
+
+  export function resolve(p: string) {
+    return path.resolve(p)
+  }
+
+  export function windowsPath(p: string) {
+    return p
+  }
+
+  export function overlaps(a: string, b: string) {
+    const relA = path.relative(a, b)
+    const relB = path.relative(b, a)
+    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..")
+  }
+
+  export function contains(parent: string, child: string) {
+    return !path.relative(parent, child).startsWith("..")
+  }
+
+  export async function findUp(target: string, start: string, stop?: string) {
+    let current = start
+    const result: string[] = []
+    while (true) {
+      const search = path.join(current, target)
+      if (await exists(search)) result.push(search)
+      if (stop === current) break
+      const parent = path.dirname(current)
+      if (parent === current) break
+      current = parent
+    }
+    return result
+  }
+
+  export async function* up(options: { targets: string[]; start: string; stop?: string }) {
+    let current = options.start
+    while (true) {
+      for (const target of options.targets) {
+        const search = path.join(current, target)
+        if (await exists(search)) yield search
+      }
+      if (options.stop === current) break
+      const parent = path.dirname(current)
+      if (parent === current) break
+      current = parent
+    }
+  }
+
+  export async function globUp(pattern: string, start: string, stop?: string) {
+    let current = start
+    const result: string[] = []
+    while (true) {
+      const dir = abs(current)
+      const regex = globToRegex(pattern, dir)
+      for (const key of files.keys()) {
+        if (regex.test(key)) result.push(key)
+      }
+      if (stop === current) break
+      const parent = path.dirname(current)
+      if (parent === current) break
+      current = parent
+    }
+    return result
+  }
+
+  // -- extra helpers for direct test manipulation --
+
+  export function _set(p: string, content: string) {
+    files.set(abs(p), content)
+  }
+
+  export function _get(p: string) {
+    return files.get(abs(p))
+  }
+
+  export function _remove(p: string) {
+    files.delete(abs(p))
+  }
+
+  export function _list() {
+    return [...files.keys()].sort()
+  }
+}
diff --git a/packages/opencode/src/storage/db.ts b/packages/opencode/src/storage/db.ts
index 1bb8c1a69b..8f3debdb44 100644
--- a/packages/opencode/src/storage/db.ts
+++ b/packages/opencode/src/storage/db.ts
@@ -28,6 +28,7 @@ const log = Log.create({ service: "db" })
 
 export namespace Database {
   export const Path = iife(() => {
+    return ':memory:'
     if (Flag.OPENCODE_DB) {
       if (path.isAbsolute(Flag.OPENCODE_DB)) return Flag.OPENCODE_DB
       return path.join(Global.Path.data, Flag.OPENCODE_DB)