release: v1.14.32

2026-05-03 15:21:31 +08:00 · 2026-05-02 15:34:01 +00:00
48 changed files with 928 additions and 2523 deletions
--- a/bun.lock
+++ b/bun.lock
@@ -29,7 +29,7 @@
    },
    "packages/app": {
      "name": "@opencode-ai/app",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode-ai/core": "workspace:*",
@@ -85,7 +85,7 @@
    },
    "packages/console/app": {
      "name": "@opencode-ai/console-app",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@ibm/plex": "6.4.1",
@@ -119,7 +119,7 @@
    },
    "packages/console/core": {
      "name": "@opencode-ai/console-core",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@aws-sdk/client-sts": "3.782.0",
        "@jsx-email/render": "1.1.1",
@@ -146,7 +146,7 @@
    },
    "packages/console/function": {
      "name": "@opencode-ai/console-function",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@ai-sdk/anthropic": "3.0.64",
        "@ai-sdk/openai": "3.0.48",
@@ -170,7 +170,7 @@
    },
    "packages/console/mail": {
      "name": "@opencode-ai/console-mail",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@jsx-email/all": "2.2.3",
        "@jsx-email/cli": "1.4.3",
@@ -194,7 +194,7 @@
    },
    "packages/core": {
      "name": "@opencode-ai/core",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "bin": {
        "opencode": "./bin/opencode",
      },
@@ -228,7 +228,7 @@
    },
    "packages/desktop": {
      "name": "@opencode-ai/desktop",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@opencode-ai/app": "workspace:*",
        "@opencode-ai/ui": "workspace:*",
@@ -263,7 +263,7 @@
    },
    "packages/desktop-electron": {
      "name": "@opencode-ai/desktop-electron",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "drizzle-orm": "catalog:",
        "effect": "catalog:",
@@ -309,7 +309,7 @@
    },
    "packages/enterprise": {
      "name": "@opencode-ai/enterprise",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@opencode-ai/core": "workspace:*",
        "@opencode-ai/ui": "workspace:*",
@@ -338,7 +338,7 @@
    },
    "packages/function": {
      "name": "@opencode-ai/function",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@octokit/auth-app": "8.0.1",
        "@octokit/rest": "catalog:",
@@ -354,7 +354,7 @@
    },
    "packages/opencode": {
      "name": "opencode",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "bin": {
        "opencode": "./bin/opencode",
      },
@@ -496,7 +496,7 @@
    },
    "packages/plugin": {
      "name": "@opencode-ai/plugin",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@opencode-ai/sdk": "workspace:*",
        "effect": "catalog:",
@@ -531,7 +531,7 @@
    },
    "packages/sdk/js": {
      "name": "@opencode-ai/sdk",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "cross-spawn": "catalog:",
      },
@@ -546,7 +546,7 @@
    },
    "packages/slack": {
      "name": "@opencode-ai/slack",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@opencode-ai/sdk": "workspace:*",
        "@slack/bolt": "^3.17.1",
@@ -581,7 +581,7 @@
    },
    "packages/ui": {
      "name": "@opencode-ai/ui",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode-ai/core": "workspace:*",
@@ -630,7 +630,7 @@
    },
    "packages/web": {
      "name": "@opencode-ai/web",
-      "version": "1.14.31",
+      "version": "1.14.32",
      "dependencies": {
        "@astrojs/cloudflare": "12.6.3",
        "@astrojs/markdown-remark": "6.3.1",
--- a/nix/hashes.json
+++ b/nix/hashes.json
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-SLWRe4uPSRWgU+NPa1BywmrUtNVIC0Oy2mjmxclxk+s=",
-    "aarch64-linux": "sha256-toHEeIqMzrmThoV0B52juGKm4pa/aJN3gBFFtrSZp2Q=",
-    "aarch64-darwin": "sha256-lYUsUxq5zR2RXjqZTEdjduOncnlwvTlxDJVKWXJuKPY=",
-    "x86_64-darwin": "sha256-77XmuEYqGwb1mkEHfnghq1VtukFTneohA0FW6WDOk1U="
+    "x86_64-linux": "sha256-OtyfKTBEHsJpjzAjN9vCR0PzGzdK6CDHdyU7eZ6Gl1s=",
+    "aarch64-linux": "sha256-3eHJs3S/+uDUPAouWPsdBOlEvAOhOYx5bJzahL0tAJk=",
+    "aarch64-darwin": "sha256-rFXzrkhPVb3yM20J8R8m7GqroNNk1vAEz+o/Ks+iAI4=",
+    "x86_64-darwin": "sha256-lb1IGgbpxg723Qxj2WVPkxKUUmyOIsFOAhA5LoZ8GwY="
  }
 }
--- a/packages/app/package.json
+++ b/packages/app/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/app",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "description": "",
  "type": "module",
  "exports": {
--- a/packages/console/app/package.json
+++ b/packages/console/app/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-app",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "type": "module",
  "license": "MIT",
  "scripts": {
--- a/packages/console/core/package.json
+++ b/packages/console/core/package.json
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode-ai/console-core",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "private": true,
  "type": "module",
  "license": "MIT",
--- a/packages/console/function/package.json
+++ b/packages/console/function/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-function",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "$schema": "https://json.schemastore.org/package.json",
  "private": true,
  "type": "module",
--- a/packages/console/mail/package.json
+++ b/packages/console/mail/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-mail",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "dependencies": {
    "@jsx-email/all": "2.2.3",
    "@jsx-email/cli": "1.4.3",
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "name": "@opencode-ai/core",
  "type": "module",
  "license": "MIT",
--- a/packages/desktop-electron/package.json
+++ b/packages/desktop-electron/package.json
@@ -1,7 +1,7 @@
 {
  "name": "@opencode-ai/desktop-electron",
  "private": true,
-  "version": "1.14.31",
+  "version": "1.14.32",
  "type": "module",
  "license": "MIT",
  "homepage": "https://opencode.ai",
--- a/packages/desktop/package.json
+++ b/packages/desktop/package.json
@@ -1,7 +1,7 @@
 {
  "name": "@opencode-ai/desktop",
  "private": true,
-  "version": "1.14.31",
+  "version": "1.14.32",
  "type": "module",
  "license": "MIT",
  "scripts": {
--- a/packages/enterprise/package.json
+++ b/packages/enterprise/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/enterprise",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "private": true,
  "type": "module",
  "license": "MIT",
--- a/packages/extensions/zed/extension.toml
+++ b/packages/extensions/zed/extension.toml
@@ -1,7 +1,7 @@
 id = "opencode"
 name = "OpenCode"
 description = "The open source coding agent."
-version = "1.14.31"
+version = "1.14.32"
 schema_version = 1
 authors = ["Anomaly"]
 repository = "https://github.com/anomalyco/opencode"
@@ -11,26 +11,26 @@ name = "OpenCode"
 icon = "./icons/opencode.svg"

 [agent_servers.opencode.targets.darwin-aarch64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.31/opencode-darwin-arm64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.32/opencode-darwin-arm64.zip"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.darwin-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.31/opencode-darwin-x64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.32/opencode-darwin-x64.zip"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.linux-aarch64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.31/opencode-linux-arm64.tar.gz"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.32/opencode-linux-arm64.tar.gz"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.linux-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.31/opencode-linux-x64.tar.gz"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.32/opencode-linux-x64.tar.gz"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.windows-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.31/opencode-windows-x64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.14.32/opencode-windows-x64.zip"
 cmd = "./opencode.exe"
 args = ["acp"]
--- a/packages/function/package.json
+++ b/packages/function/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/function",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "$schema": "https://json.schemastore.org/package.json",
  "private": true,
  "type": "module",
--- a/packages/opencode/package.json
+++ b/packages/opencode/package.json
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "name": "opencode",
  "type": "module",
  "license": "MIT",
--- a/packages/opencode/script/httpapi-exercise.ts
+++ b/packages/opencode/script/httpapi-exercise.ts
--- a/packages/opencode/src/cli/bootstrap.ts
+++ b/packages/opencode/src/cli/bootstrap.ts
@@ -9,7 +9,7 @@ export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
        const result = await cb()
        return result
      } finally {
-        await InstanceStore.disposeInstance(Instance.current)
+        await InstanceStore.runtime.runPromise((s) => s.dispose(Instance.current))
      }
    },
  })
--- a/packages/opencode/src/cli/cmd/tui/worker.ts
+++ b/packages/opencode/src/cli/cmd/tui/worker.ts
@@ -88,7 +88,7 @@ export const rpc = {
  async shutdown() {
    Log.Default.info("worker shutting down")

-    await InstanceStore.disposeAllInstances()
+    await InstanceStore.runtime.runPromise((s) => s.disposeAll())
    if (server) await server.stop(true)
  },
 }
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -13,6 +13,7 @@ import { Env } from "../env"
 import { applyEdits, modify } from "jsonc-parser"
 import { type InstanceContext } from "../project/instance"
 import { InstanceStore } from "../project/instance-store"
+import { InstanceRef } from "@/effect/instance-ref"
 import { InstallationLocal, InstallationVersion } from "@opencode-ai/core/installation/version"
 import { existsSync } from "fs"
 import { GlobalBus } from "@/bus/global"
@@ -738,17 +739,15 @@ export const layer = Layer.effect(
        .writeFileString(file, JSON.stringify(mergeDeep(writable(existing), writable(config)), null, 2))
        .pipe(Effect.orDie)
      if (options?.dispose !== false) {
-        // Fail loudly if no instance is bound — silently skipping would
-        // mask "config update without an active instance" bugs. The throw
-        // comes from `Instance.current` inside `InstanceState.context`.
-        const ctx = yield* InstanceState.context
-        yield* Effect.promise(() => InstanceStore.disposeInstance(ctx))
+        const ctx = yield* InstanceRef
+        if (ctx) yield* Effect.promise(() => InstanceStore.runtime.runPromise((s) => s.dispose(ctx)))
      }
    })

    const invalidate = Effect.fn("Config.invalidate")(function* (wait?: boolean) {
      yield* invalidateGlobal
-      const task = InstanceStore.disposeAllInstances()
+      const task = InstanceStore.runtime
+        .runPromise((s) => s.disposeAll())
        .catch(() => undefined)
        .finally(() =>
          GlobalBus.emit("event", {
--- a/packages/opencode/src/project/instance-store.ts
+++ b/packages/opencode/src/project/instance-store.ts
@@ -1,7 +1,7 @@
 import { GlobalBus } from "@/bus/global"
 import { WorkspaceContext } from "@/control-plane/workspace-context"
 import { InstanceRef } from "@/effect/instance-ref"
-import { disposeInstance as runDisposers } from "@/effect/instance-registry"
+import { disposeInstance } from "@/effect/instance-registry"
 import { makeRuntime } from "@/effect/run-service"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { Context, Deferred, Duration, Effect, Exit, Layer, Scope } from "effect"
@@ -94,7 +94,7 @@ export const layer: Layer.Layer<Service, never, Project.Service> = Layer.effect(

    const disposeContext = Effect.fn("InstanceStore.disposeContext")(function* (ctx: InstanceContext) {
      yield* Effect.logInfo("disposing instance", { directory: ctx.directory })
-      yield* Effect.promise(() => runDisposers(ctx.directory))
+      yield* Effect.promise(() => disposeInstance(ctx.directory))
      yield* emitDisposed({ directory: ctx.directory, project: ctx.project.id })
    })

@@ -135,7 +135,7 @@ export const layer: Layer.Layer<Service, never, Project.Service> = Layer.effect(
            yield* Effect.logInfo("reloading instance", { directory })
            if (previous) {
              yield* Deferred.await(previous.deferred).pipe(Effect.ignore)
-              yield* Effect.promise(() => runDisposers(directory))
+              yield* Effect.promise(() => disposeInstance(directory))
              yield* emitDisposed({ directory, project: input.project?.id })
            }
            yield* completeLoad(directory, input, entry)
@@ -197,11 +197,4 @@ export const defaultLayer = layer.pipe(Layer.provide(Project.defaultLayer))

 export const runtime = makeRuntime(Service, defaultLayer)

-// Promise-returning helpers for callers without an Effect runtime in scope.
-// They route through `runtime` (not a yielded Service from a fresh runtime)
-// so they share the cache that `Instance.provide` populates.
-export const disposeInstance = (ctx: InstanceContext) => runtime.runPromise((store) => store.dispose(ctx))
-export const disposeAllInstances = () => runtime.runPromise((store) => store.disposeAll())
-export const reloadInstance = (input: LoadInput) => runtime.runPromise((store) => store.reload(input))
-
 export * as InstanceStore from "./instance-store"
--- a/packages/opencode/src/project/instance.ts
+++ b/packages/opencode/src/project/instance.ts
@@ -42,17 +42,10 @@ export const Instance = {
  restore<R>(ctx: InstanceContext, fn: () => R): R {
    return context.provide(ctx, fn)
  },
-  // followup: `reload` survives because `test/server/project-init-git.test.ts`
-  // spies on this exact method. Once that test asserts on `InstanceStore.reloadInstance`
-  // (or moves to an Effect runtime), this wrapper can drop.
  async reload(input: InstanceStore.LoadInput) {
-    return InstanceStore.reloadInstance(input)
+    return InstanceStore.runtime.runPromise((store) => store.reload(input))
  },
-  // followup: `dispose` survives for legacy fixtures that read `Instance.current`
-  // out of ALS (e.g. `test/fixture/fixture.ts` `provideTmpdirInstance`,
-  // `test/question/question.test.ts` cancellation tests). Convert those to call
-  // `InstanceStore.disposeInstance(ctx)` directly once `Instance.provide` is gone.
  async dispose() {
-    return InstanceStore.disposeInstance(Instance.current)
+    return InstanceStore.runtime.runPromise((store) => store.dispose(Instance.current))
  },
 }
--- a/packages/opencode/src/server/routes/global.ts
+++ b/packages/opencode/src/server/routes/global.ts
@@ -200,7 +200,7 @@ export const GlobalRoutes = lazy(() =>
        },
      }),
      async (c) => {
-        await InstanceStore.disposeAllInstances()
+        await InstanceStore.runtime.runPromise((s) => s.disposeAll())
        GlobalBus.emit("event", {
          directory: "global",
          payload: {
--- a/packages/opencode/src/server/routes/instance/index.ts
+++ b/packages/opencode/src/server/routes/instance/index.ts
@@ -63,7 +63,7 @@ export const InstanceRoutes = (upgrade: UpgradeWebSocket): Hono => {
        },
      }),
      async (c) => {
-        await InstanceStore.disposeInstance(Instance.current)
+        await InstanceStore.runtime.runPromise((s) => s.dispose(Instance.current))
        return c.json(true)
      },
    )
--- a/packages/opencode/src/server/routes/instance/project.ts
+++ b/packages/opencode/src/server/routes/instance/project.ts
@@ -81,11 +81,7 @@ export const ProjectRoutes = lazy(() =>
          Project.Service.use((svc) => svc.initGit({ directory: dir, project: prev })),
        )
        if (next.id === prev.id && next.vcs === prev.vcs && next.worktree === prev.worktree) return c.json(next)
-        await Instance.reload({
-          directory: dir,
-          worktree: dir,
-          project: next,
-        })
+        await Instance.reload({ directory: dir, worktree: dir, project: next })
        return c.json(next)
      },
    )
--- a/packages/opencode/src/server/routes/instance/tui.ts
+++ b/packages/opencode/src/server/routes/instance/tui.ts
@@ -26,17 +26,13 @@ export function nextTuiRequest() {
  return request.next()
 }

-export function submitTuiRequest(body: TuiRequest) {
-  request.push(body)
-}
-
 export function submitTuiResponse(body: unknown) {
  response.push(body)
 }

 export async function callTui(ctx: Context) {
  const body = await ctx.req.json()
-  submitTuiRequest({
+  request.push({
    path: ctx.req.path,
    body,
  })
--- a/packages/opencode/src/storage/db.ts
+++ b/packages/opencode/src/storage/db.ts
@@ -122,7 +122,6 @@ export const Client = lazy(() => {
 })

 export function close() {
-  if (!Client.loaded()) return
  Client().$client.close()
  Client.reset()
 }
--- a/packages/opencode/src/util/lazy.ts
+++ b/packages/opencode/src/util/lazy.ts
@@ -14,7 +14,5 @@ export function lazy<T>(fn: () => T) {
    value = undefined
  }

-  result.loaded = () => loaded
-
  return result
 }
--- a/packages/opencode/test/AGENTS.md
+++ b/packages/opencode/test/AGENTS.md
@@ -89,17 +89,20 @@ Use `testEffect(...)` from `test/lib/effect.ts` for tests that exercise Effect s
 ```typescript
 import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
+import { provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"

 const it = testEffect(Layer.mergeAll(MyService.defaultLayer))

 describe("my service", () => {
-  it.instance("does the thing", () =>
-    Effect.gen(function* () {
-      const svc = yield* MyService.Service
-      const out = yield* svc.run()
-      expect(out).toEqual("ok")
-    }),
+  it.live("does the thing", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const svc = yield* MyService.Service
+        const out = yield* svc.run()
+        expect(out).toEqual("ok")
+      }),
+    ),
  )
 })
 ```
@@ -108,7 +111,6 @@ describe("my service", () => {

 - Use `it.effect(...)` when the test should run with `TestClock` and `TestConsole`.
 - Use `it.live(...)` when the test depends on real time, filesystem mtimes, child processes, git, locks, or other live OS behavior.
- Use `it.instance(...)` for live Effect tests that need a scoped temporary directory and instance context.
 - Most integration-style tests in this package use `it.live(...)`.

 ### Effect Fixtures
@@ -120,20 +122,7 @@ Prefer the Effect-aware helpers from `fixture/fixture.ts` instead of building a
 - `provideTmpdirInstance((dir) => effect, options?)` is the convenience helper. It creates a temp directory, binds it as the active instance, and disposes the instance on cleanup.
 - `provideTmpdirServer((input) => effect, options?)` does the same, but also provides the test LLM server.

-Use `it.instance(...)` by default when a test only needs one temp instance. Yield `TestInstance` from `fixture/fixture.ts` when the test needs the temp directory path:
-
-```typescript
-import { TestInstance } from "../fixture/fixture"
-
-it.instance("uses the temp directory", () =>
-  Effect.gen(function* () {
-    const test = yield* TestInstance
-    expect(test.directory).toContain("opencode-test-")
-  }),
-)
-```
-
-Use `provideTmpdirInstance(...)` or `tmpdirScoped()` plus `provideInstance(...)` when a test needs multiple directories, custom setup before binding, needs to switch instance context within one test, or explicitly tests instance disposal/reload lifetime.
+Use `provideTmpdirInstance(...)` by default when a test only needs one temp instance. Use `tmpdirScoped()` plus `provideInstance(...)` when a test needs multiple directories, custom setup before binding, or needs to switch instance context within one test.

 ### Style

@@ -141,4 +130,4 @@ Use `provideTmpdirInstance(...)` or `tmpdirScoped()` plus `provideInstance(...)`
 - Keep the test body inside `Effect.gen(function* () { ... })`.
 - Yield services directly with `yield* MyService.Service` or `yield* MyTool`.
 - Avoid custom `ManagedRuntime`, `attach(...)`, or ad hoc `run(...)` wrappers when `testEffect(...)` already provides the runtime.
- When a test needs instance-local state, prefer `it.instance(...)` over manual `Instance.provide(...)` inside Promise-style tests.
+- When a test needs instance-local state, prefer `provideTmpdirInstance(...)` or `provideInstance(...)` over manual `Instance.provide(...)` inside Promise-style tests.
--- a/packages/opencode/test/bus/bus-effect.test.ts
+++ b/packages/opencode/test/bus/bus-effect.test.ts
@@ -2,8 +2,9 @@ import { describe, expect } from "bun:test"
 import { Deferred, Effect, Layer, Schema, Stream } from "effect"
 import { Bus } from "../../src/bus"
 import { BusEvent } from "../../src/bus/bus-event"
+import { Instance } from "../../src/project/instance"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
-import { disposeAllInstances, provideInstance, tmpdirScoped } from "../fixture/fixture"
+import { disposeAllInstances, provideInstance, provideTmpdirInstance, tmpdirScoped } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"

 const TestEvent = {
@@ -18,103 +19,111 @@ const live = Layer.mergeAll(Bus.layer, node)
 const it = testEffect(live)

 describe("Bus (Effect-native)", () => {
-  it.instance("publish + subscribe stream delivers events", () =>
-    Effect.gen(function* () {
-      const bus = yield* Bus.Service
-      const received: number[] = []
-      const done = yield* Deferred.make<void>()
+  it.live("publish + subscribe stream delivers events", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        const received: number[] = []
+        const done = yield* Deferred.make<void>()

-      yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
-        Effect.sync(() => {
-          received.push(evt.properties.value)
-          if (received.length === 2) Deferred.doneUnsafe(done, Effect.void)
-        }),
-      ).pipe(Effect.forkScoped)
+        yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
+          Effect.sync(() => {
+            received.push(evt.properties.value)
+            if (received.length === 2) Deferred.doneUnsafe(done, Effect.void)
+          }),
+        ).pipe(Effect.forkScoped)

-      yield* Effect.sleep("10 millis")
-      yield* bus.publish(TestEvent.Ping, { value: 1 })
-      yield* bus.publish(TestEvent.Ping, { value: 2 })
-      yield* Deferred.await(done)
+        yield* Effect.sleep("10 millis")
+        yield* bus.publish(TestEvent.Ping, { value: 1 })
+        yield* bus.publish(TestEvent.Ping, { value: 2 })
+        yield* Deferred.await(done)

-      expect(received).toEqual([1, 2])
-    }),
+        expect(received).toEqual([1, 2])
+      }),
+    ),
  )

-  it.instance("subscribe filters by event type", () =>
-    Effect.gen(function* () {
-      const bus = yield* Bus.Service
-      const pings: number[] = []
-      const done = yield* Deferred.make<void>()
+  it.live("subscribe filters by event type", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        const pings: number[] = []
+        const done = yield* Deferred.make<void>()

-      yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
-        Effect.sync(() => {
-          pings.push(evt.properties.value)
-          Deferred.doneUnsafe(done, Effect.void)
-        }),
-      ).pipe(Effect.forkScoped)
+        yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
+          Effect.sync(() => {
+            pings.push(evt.properties.value)
+            Deferred.doneUnsafe(done, Effect.void)
+          }),
+        ).pipe(Effect.forkScoped)

-      yield* Effect.sleep("10 millis")
-      yield* bus.publish(TestEvent.Pong, { message: "ignored" })
-      yield* bus.publish(TestEvent.Ping, { value: 42 })
-      yield* Deferred.await(done)
+        yield* Effect.sleep("10 millis")
+        yield* bus.publish(TestEvent.Pong, { message: "ignored" })
+        yield* bus.publish(TestEvent.Ping, { value: 42 })
+        yield* Deferred.await(done)

-      expect(pings).toEqual([42])
-    }),
+        expect(pings).toEqual([42])
+      }),
+    ),
  )

-  it.instance("subscribeAll receives all types", () =>
-    Effect.gen(function* () {
-      const bus = yield* Bus.Service
-      const types: string[] = []
-      const done = yield* Deferred.make<void>()
+  it.live("subscribeAll receives all types", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        const types: string[] = []
+        const done = yield* Deferred.make<void>()

-      yield* Stream.runForEach(bus.subscribeAll(), (evt) =>
-        Effect.sync(() => {
-          types.push(evt.type)
-          if (types.length === 2) Deferred.doneUnsafe(done, Effect.void)
-        }),
-      ).pipe(Effect.forkScoped)
+        yield* Stream.runForEach(bus.subscribeAll(), (evt) =>
+          Effect.sync(() => {
+            types.push(evt.type)
+            if (types.length === 2) Deferred.doneUnsafe(done, Effect.void)
+          }),
+        ).pipe(Effect.forkScoped)

-      yield* Effect.sleep("10 millis")
-      yield* bus.publish(TestEvent.Ping, { value: 1 })
-      yield* bus.publish(TestEvent.Pong, { message: "hi" })
-      yield* Deferred.await(done)
+        yield* Effect.sleep("10 millis")
+        yield* bus.publish(TestEvent.Ping, { value: 1 })
+        yield* bus.publish(TestEvent.Pong, { message: "hi" })
+        yield* Deferred.await(done)

-      expect(types).toContain("test.effect.ping")
-      expect(types).toContain("test.effect.pong")
-    }),
+        expect(types).toContain("test.effect.ping")
+        expect(types).toContain("test.effect.pong")
+      }),
+    ),
  )

-  it.instance("multiple subscribers each receive the event", () =>
-    Effect.gen(function* () {
-      const bus = yield* Bus.Service
-      const a: number[] = []
-      const b: number[] = []
-      const doneA = yield* Deferred.make<void>()
-      const doneB = yield* Deferred.make<void>()
+  it.live("multiple subscribers each receive the event", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        const a: number[] = []
+        const b: number[] = []
+        const doneA = yield* Deferred.make<void>()
+        const doneB = yield* Deferred.make<void>()

-      yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
-        Effect.sync(() => {
-          a.push(evt.properties.value)
-          Deferred.doneUnsafe(doneA, Effect.void)
-        }),
-      ).pipe(Effect.forkScoped)
+        yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
+          Effect.sync(() => {
+            a.push(evt.properties.value)
+            Deferred.doneUnsafe(doneA, Effect.void)
+          }),
+        ).pipe(Effect.forkScoped)

-      yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
-        Effect.sync(() => {
-          b.push(evt.properties.value)
-          Deferred.doneUnsafe(doneB, Effect.void)
-        }),
-      ).pipe(Effect.forkScoped)
+        yield* Stream.runForEach(bus.subscribe(TestEvent.Ping), (evt) =>
+          Effect.sync(() => {
+            b.push(evt.properties.value)
+            Deferred.doneUnsafe(doneB, Effect.void)
+          }),
+        ).pipe(Effect.forkScoped)

-      yield* Effect.sleep("10 millis")
-      yield* bus.publish(TestEvent.Ping, { value: 99 })
-      yield* Deferred.await(doneA)
-      yield* Deferred.await(doneB)
+        yield* Effect.sleep("10 millis")
+        yield* bus.publish(TestEvent.Ping, { value: 99 })
+        yield* Deferred.await(doneA)
+        yield* Deferred.await(doneB)

-      expect(a).toEqual([99])
-      expect(b).toEqual([99])
-    }),
+        expect(a).toEqual([99])
+        expect(b).toEqual([99])
+      }),
+    ),
  )

  it.live("subscribeAll stream sees InstanceDisposed on disposal", () =>
--- a/packages/opencode/test/fixture/fixture.ts
+++ b/packages/opencode/test/fixture/fixture.ts
@@ -5,7 +5,6 @@ import path from "path"
 import { Effect, Context } from "effect"
 import type * as PlatformError from "effect/PlatformError"
 import type * as Scope from "effect/Scope"
-import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import type { Config } from "@/config/config"
 import { InstanceRef } from "../../src/effect/instance-ref"
@@ -13,9 +12,12 @@ import { Instance } from "../../src/project/instance"
 import { InstanceStore } from "../../src/project/instance-store"
 import { TestLLMServer } from "../lib/llm-server"

-// Re-export for test ergonomics. The implementation lives next to the runtime
-// it consumes; see `InstanceStore.disposeAllInstances` for the rationale.
-export { disposeAllInstances } from "../../src/project/instance-store"
+// Test helper for tearing down all loaded instances. Used in afterEach hooks.
+// Replaces direct Instance.disposeAll() calls so the legacy promise method can be removed.
+// IMPORTANT: must use InstanceStore.runtime, not AppRuntime or a test-layer Service —
+// Instance.provide loads instances into InstanceStore.runtime's Service cache, and that
+// Service is built per-runtime (not shared via memoMap across Effect.runPromise boundaries).
+export const disposeAllInstances = () => InstanceStore.runtime.runPromise((s) => s.disposeAll())

 // Strip null bytes from paths (defensive fix for CI environment issues)
 function sanitizePath(p: string): string {
@@ -162,18 +164,6 @@ export function provideTmpdirInstance<A, E, R>(
  })
 }

-export class TestInstance extends Context.Service<TestInstance, { readonly directory: string }>()("@test/Instance") {}
-
-export const withTmpdirInstance =
-  (options?: { git?: boolean; config?: Partial<Config.Info> }) =>
-  <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    Effect.gen(function* () {
-      const directory = yield* tmpdirScoped(options)
-      return yield* InstanceStore.Service.use((store) =>
-        store.provide({ directory }, self.pipe(Effect.provideService(TestInstance, { directory }))),
-      )
-    }).pipe(Effect.provide(InstanceStore.defaultLayer), Effect.provide(CrossSpawnSpawner.defaultLayer))
-
 export function provideTmpdirServer<A, E, R>(
  self: (input: { dir: string; llm: TestLLMServer["Service"] }) => Effect.Effect<A, E, R>,
  options?: { git?: boolean; config?: (url: string) => Partial<Config.Info> },
--- a/packages/opencode/test/lib/effect.ts
+++ b/packages/opencode/test/lib/effect.ts
@@ -3,11 +3,8 @@ import { Cause, Effect, Exit, Layer } from "effect"
 import type * as Scope from "effect/Scope"
 import * as TestClock from "effect/testing/TestClock"
 import * as TestConsole from "effect/testing/TestConsole"
-import type { Config } from "@/config/config"
-import { TestInstance, withTmpdirInstance } from "../fixture/fixture"

 type Body<A, E, R> = Effect.Effect<A, E, R> | (() => Effect.Effect<A, E, R>)
-type InstanceOptions = { git?: boolean; config?: Partial<Config.Info> }

 const body = <A, E, R>(value: Body<A, E, R>) => Effect.suspend(() => (typeof value === "function" ? value() : value))

@@ -41,28 +38,7 @@ const make = <R, E>(testLayer: Layer.Layer<R, E>, liveLayer: Layer.Layer<R, E>)
  live.skip = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
    test.skip(name, () => run(value, liveLayer), opts)

-  const instance = <A, E2>(
-    name: string,
-    value: Body<A, E2, R | TestInstance | Scope.Scope>,
-    instanceOptions?: InstanceOptions,
-    opts?: number | TestOptions,
-  ) => test(name, () => run(body(value).pipe(withTmpdirInstance(instanceOptions)), liveLayer), opts)
-
-  instance.only = <A, E2>(
-    name: string,
-    value: Body<A, E2, R | TestInstance | Scope.Scope>,
-    instanceOptions?: InstanceOptions,
-    opts?: number | TestOptions,
-  ) => test.only(name, () => run(body(value).pipe(withTmpdirInstance(instanceOptions)), liveLayer), opts)
-
-  instance.skip = <A, E2>(
-    name: string,
-    value: Body<A, E2, R | TestInstance | Scope.Scope>,
-    instanceOptions?: InstanceOptions,
-    opts?: number | TestOptions,
-  ) => test.skip(name, () => run(body(value).pipe(withTmpdirInstance(instanceOptions)), liveLayer), opts)
-
-  return { effect, live, instance }
+  return { effect, live }
 }

 // Test environment with TestClock and TestConsole
--- a/packages/opencode/test/question/question.test.ts
+++ b/packages/opencode/test/question/question.test.ts
@@ -1,63 +1,64 @@
-import { afterEach, expect } from "bun:test"
-import { Cause, Effect, Exit, Fiber, Layer } from "effect"
+import { afterEach, test, expect } from "bun:test"
 import { Question } from "../../src/question"
 import { Instance } from "../../src/project/instance"
 import { QuestionID } from "../../src/question/schema"
-import { disposeAllInstances, provideInstance, tmpdirScoped } from "../fixture/fixture"
+import { disposeAllInstances, tmpdir } from "../fixture/fixture"
 import { SessionID } from "../../src/session/schema"
-import { testEffect } from "../lib/effect"
-import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+import { AppRuntime } from "../../src/effect/app-runtime"

-const it = testEffect(Layer.mergeAll(Question.defaultLayer, CrossSpawnSpawner.defaultLayer))
+const ask = (input: { sessionID: SessionID; questions: ReadonlyArray<Question.Info>; tool?: Question.Tool }) =>
+  AppRuntime.runPromise(Question.Service.use((svc) => svc.ask(input)))

-const askEffect = Effect.fn("QuestionTest.ask")(function* (input: {
-  sessionID: SessionID
-  questions: ReadonlyArray<Question.Info>
-  tool?: Question.Tool
-}) {
-  const question = yield* Question.Service
-  return yield* question.ask(input)
-})
+const list = () => AppRuntime.runPromise(Question.Service.use((svc) => svc.list()))

-const listEffect = Question.Service.use((svc) => svc.list())
+const reply = (input: { requestID: QuestionID; answers: ReadonlyArray<Question.Answer> }) =>
+  AppRuntime.runPromise(Question.Service.use((svc) => svc.reply(input)))

-const replyEffect = Effect.fn("QuestionTest.reply")(function* (input: {
-  requestID: QuestionID
-  answers: ReadonlyArray<Question.Answer>
-}) {
-  const question = yield* Question.Service
-  yield* question.reply(input)
-})
-
-const rejectEffect = Effect.fn("QuestionTest.reject")(function* (id: QuestionID) {
-  const question = yield* Question.Service
-  yield* question.reject(id)
-})
+const reject = (id: QuestionID) => AppRuntime.runPromise(Question.Service.use((svc) => svc.reject(id)))

 afterEach(async () => {
  await disposeAllInstances()
 })

 /** Reject all pending questions so dangling Deferred fibers don't hang the test. */
-const rejectAll = Effect.gen(function* () {
-  yield* Effect.forEach(yield* listEffect, (req) => rejectEffect(req.id), { discard: true })
+async function rejectAll() {
+  const pending = await list()
+  for (const req of pending) {
+    await reject(req.id)
+  }
+}
+
+test("ask - returns pending promise", async () => {
+  await using tmp = await tmpdir({ git: true })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const promise = ask({
+        sessionID: SessionID.make("ses_test"),
+        questions: [
+          {
+            question: "What would you like to do?",
+            header: "Action",
+            options: [
+              { label: "Option 1", description: "First option" },
+              { label: "Option 2", description: "Second option" },
+            ],
+          },
+        ],
+      })
+      expect(promise).toBeInstanceOf(Promise)
+      await rejectAll()
+      await promise.catch(() => {})
+    },
+  })
 })

-const waitForPending = (count: number) =>
-  Effect.gen(function* () {
-    for (let i = 0; i < 100; i++) {
-      const pending = yield* listEffect
-      if (pending.length === count) return pending
-      yield* Effect.sleep("10 millis")
-    }
-    return yield* Effect.fail(new Error(`timed out waiting for ${count} pending question request(s)`))
-  })
-
-it.instance("ask - remains pending until answered", () =>
-  Effect.gen(function* () {
-    const fiber = yield* askEffect({
-      sessionID: SessionID.make("ses_test"),
-      questions: [
+test("ask - adds to pending list", async () => {
+  await using tmp = await tmpdir({ git: true })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const questions = [
        {
          question: "What would you like to do?",
          header: "Action",
@@ -66,81 +67,30 @@ it.instance("ask - remains pending until answered", () =>
            { label: "Option 2", description: "Second option" },
          ],
        },
-      ],
-    }).pipe(Effect.forkScoped)
+      ]

-    expect(yield* waitForPending(1)).toHaveLength(1)
-    yield* rejectAll
-    expect((yield* Fiber.await(fiber))._tag).toBe("Failure")
-  }),
-  { git: true },
-)
+      const promise = ask({
+        sessionID: SessionID.make("ses_test"),
+        questions,
+      })

-it.instance("ask - adds to pending list", () =>
-  Effect.gen(function* () {
-    const questions = [
-      {
-        question: "What would you like to do?",
-        header: "Action",
-        options: [
-          { label: "Option 1", description: "First option" },
-          { label: "Option 2", description: "Second option" },
-        ],
-      },
-    ]
-
-    const fiber = yield* askEffect({
-      sessionID: SessionID.make("ses_test"),
-      questions,
-    }).pipe(Effect.forkScoped)
-
-    const pending = yield* waitForPending(1)
-    expect(pending.length).toBe(1)
-    expect(pending[0].questions).toEqual(questions)
-    yield* rejectAll
-    expect((yield* Fiber.await(fiber))._tag).toBe("Failure")
-  }),
-  { git: true },
-)
+      const pending = await list()
+      expect(pending.length).toBe(1)
+      expect(pending[0].questions).toEqual(questions)
+      await rejectAll()
+      await promise.catch(() => {})
+    },
+  })
+})

 // reply tests

-it.instance("reply - resolves the pending ask with answers", () =>
-  Effect.gen(function* () {
-    const questions = [
-      {
-        question: "What would you like to do?",
-        header: "Action",
-        options: [
-          { label: "Option 1", description: "First option" },
-          { label: "Option 2", description: "Second option" },
-        ],
-      },
-    ]
-
-    const fiber = yield* askEffect({
-      sessionID: SessionID.make("ses_test"),
-      questions,
-    }).pipe(Effect.forkScoped)
-
-    const pending = yield* waitForPending(1)
-    const requestID = pending[0].id
-
-    yield* replyEffect({
-      requestID,
-      answers: [["Option 1"]],
-    })
-
-    expect(yield* Fiber.join(fiber)).toEqual([["Option 1"]])
-  }),
-  { git: true },
-)
-
-it.instance("reply - removes from pending list", () =>
-  Effect.gen(function* () {
-    const fiber = yield* askEffect({
-      sessionID: SessionID.make("ses_test"),
-      questions: [
+test("reply - resolves the pending ask with answers", async () => {
+  await using tmp = await tmpdir({ git: true })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const questions = [
        {
          question: "What would you like to do?",
          header: "Action",
@@ -149,258 +99,366 @@ it.instance("reply - removes from pending list", () =>
            { label: "Option 2", description: "Second option" },
          ],
        },
-      ],
-    }).pipe(Effect.forkScoped)
+      ]

-    const pending = yield* waitForPending(1)
-    expect(pending.length).toBe(1)
+      const promise = ask({
+        sessionID: SessionID.make("ses_test"),
+        questions,
+      })

-    yield* replyEffect({
-      requestID: pending[0].id,
-      answers: [["Option 1"]],
-    })
-    yield* Fiber.join(fiber)
+      const pending = await list()
+      const requestID = pending[0].id

-    const after = yield* listEffect
-    expect(after.length).toBe(0)
-  }),
-  { git: true },
-)
+      await reply({
+        requestID,
+        answers: [["Option 1"]],
+      })

-it.instance("reply - does nothing for unknown requestID", () =>
-  replyEffect({
-    requestID: QuestionID.make("que_unknown"),
-    answers: [["Option 1"]],
-  }),
-  { git: true },
-)
+      const answers = await promise
+      expect(answers).toEqual([["Option 1"]])
+    },
+  })
+})
+
+test("reply - removes from pending list", async () => {
+  await using tmp = await tmpdir({ git: true })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const promise = ask({
+        sessionID: SessionID.make("ses_test"),
+        questions: [
+          {
+            question: "What would you like to do?",
+            header: "Action",
+            options: [
+              { label: "Option 1", description: "First option" },
+              { label: "Option 2", description: "Second option" },
+            ],
+          },
+        ],
+      })
+
+      const pending = await list()
+      expect(pending.length).toBe(1)
+
+      await reply({
+        requestID: pending[0].id,
+        answers: [["Option 1"]],
+      })
+      await promise
+
+      const after = await list()
+      expect(after.length).toBe(0)
+    },
+  })
+})
+
+test("reply - does nothing for unknown requestID", async () => {
+  await using tmp = await tmpdir({ git: true })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      await reply({
+        requestID: QuestionID.make("que_unknown"),
+        answers: [["Option 1"]],
+      })
+      // Should not throw
+    },
+  })
+})

 // reject tests

-it.instance("reject - throws RejectedError", () =>
-  Effect.gen(function* () {
-    const fiber = yield* askEffect({
-      sessionID: SessionID.make("ses_test"),
-      questions: [
-        {
-          question: "What would you like to do?",
-          header: "Action",
-          options: [
-            { label: "Option 1", description: "First option" },
-            { label: "Option 2", description: "Second option" },
-          ],
-        },
-      ],
-    }).pipe(Effect.forkScoped)
+test("reject - throws RejectedError", async () => {
+  await using tmp = await tmpdir({ git: true })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const promise = ask({
+        sessionID: SessionID.make("ses_test"),
+        questions: [
+          {
+            question: "What would you like to do?",
+            header: "Action",
+            options: [
+              { label: "Option 1", description: "First option" },
+              { label: "Option 2", description: "Second option" },
+            ],
+          },
+        ],
+      })

-    const pending = yield* waitForPending(1)
-    yield* rejectEffect(pending[0].id)
+      const pending = await list()
+      await reject(pending[0].id)

-    const exit = yield* Fiber.await(fiber)
-    expect(exit._tag).toBe("Failure")
-    if (exit._tag === "Failure") expect(exit.cause.toString()).toContain("QuestionRejectedError")
-  }),
-  { git: true },
-)
+      await expect(promise).rejects.toBeInstanceOf(Question.RejectedError)
+    },
+  })
+})

-it.instance("reject - removes from pending list", () =>
-  Effect.gen(function* () {
-    const fiber = yield* askEffect({
-      sessionID: SessionID.make("ses_test"),
-      questions: [
-        {
-          question: "What would you like to do?",
-          header: "Action",
-          options: [
-            { label: "Option 1", description: "First option" },
-            { label: "Option 2", description: "Second option" },
-          ],
-        },
-      ],
-    }).pipe(Effect.forkScoped)
+test("reject - removes from pending list", async () => {
+  await using tmp = await tmpdir({ git: true })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const promise = ask({
+        sessionID: SessionID.make("ses_test"),
+        questions: [
+          {
+            question: "What would you like to do?",
+            header: "Action",
+            options: [
+              { label: "Option 1", description: "First option" },
+              { label: "Option 2", description: "Second option" },
+            ],
+          },
+        ],
+      })

-    const pending = yield* waitForPending(1)
-    expect(pending.length).toBe(1)
+      const pending = await list()
+      expect(pending.length).toBe(1)

-    yield* rejectEffect(pending[0].id)
-    expect((yield* Fiber.await(fiber))._tag).toBe("Failure")
+      await reject(pending[0].id)
+      promise.catch(() => {}) // Ignore rejection

-    const after = yield* listEffect
-    expect(after.length).toBe(0)
-  }),
-  { git: true },
-)
+      const after = await list()
+      expect(after.length).toBe(0)
+    },
+  })
+})

-it.instance("reject - does nothing for unknown requestID", () => rejectEffect(QuestionID.make("que_unknown")), { git: true })
+test("reject - does nothing for unknown requestID", async () => {
+  await using tmp = await tmpdir({ git: true })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      await reject(QuestionID.make("que_unknown"))
+      // Should not throw
+    },
+  })
+})

 // multiple questions tests

-it.instance("ask - handles multiple questions", () =>
-  Effect.gen(function* () {
-    const questions = [
-      {
-        question: "What would you like to do?",
-        header: "Action",
-        options: [
-          { label: "Build", description: "Build the project" },
-          { label: "Test", description: "Run tests" },
-        ],
-      },
-      {
-        question: "Which environment?",
-        header: "Env",
-        options: [
-          { label: "Dev", description: "Development" },
-          { label: "Prod", description: "Production" },
-        ],
-      },
-    ]
+test("ask - handles multiple questions", async () => {
+  await using tmp = await tmpdir({ git: true })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const questions = [
+        {
+          question: "What would you like to do?",
+          header: "Action",
+          options: [
+            { label: "Build", description: "Build the project" },
+            { label: "Test", description: "Run tests" },
+          ],
+        },
+        {
+          question: "Which environment?",
+          header: "Env",
+          options: [
+            { label: "Dev", description: "Development" },
+            { label: "Prod", description: "Production" },
+          ],
+        },
+      ]

-    const fiber = yield* askEffect({
-      sessionID: SessionID.make("ses_test"),
-      questions,
-    }).pipe(Effect.forkScoped)
+      const promise = ask({
+        sessionID: SessionID.make("ses_test"),
+        questions,
+      })

-    const pending = yield* waitForPending(1)
+      const pending = await list()

-    yield* replyEffect({
-      requestID: pending[0].id,
-      answers: [["Build"], ["Dev"]],
-    })
+      await reply({
+        requestID: pending[0].id,
+        answers: [["Build"], ["Dev"]],
+      })

-    expect(yield* Fiber.join(fiber)).toEqual([["Build"], ["Dev"]])
-  }),
-  { git: true },
-)
+      const answers = await promise
+      expect(answers).toEqual([["Build"], ["Dev"]])
+    },
+  })
+})

 // list tests

-it.instance("list - returns all pending requests", () =>
-  Effect.gen(function* () {
-    const fiber1 = yield* askEffect({
-      sessionID: SessionID.make("ses_test1"),
-      questions: [
-        {
-          question: "Question 1?",
-          header: "Q1",
-          options: [{ label: "A", description: "A" }],
-        },
-      ],
-    }).pipe(Effect.forkScoped)
+test("list - returns all pending requests", async () => {
+  await using tmp = await tmpdir({ git: true })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const p1 = ask({
+        sessionID: SessionID.make("ses_test1"),
+        questions: [
+          {
+            question: "Question 1?",
+            header: "Q1",
+            options: [{ label: "A", description: "A" }],
+          },
+        ],
+      })

-    const fiber2 = yield* askEffect({
-      sessionID: SessionID.make("ses_test2"),
-      questions: [
-        {
-          question: "Question 2?",
-          header: "Q2",
-          options: [{ label: "B", description: "B" }],
-        },
-      ],
-    }).pipe(Effect.forkScoped)
+      const p2 = ask({
+        sessionID: SessionID.make("ses_test2"),
+        questions: [
+          {
+            question: "Question 2?",
+            header: "Q2",
+            options: [{ label: "B", description: "B" }],
+          },
+        ],
+      })

-    const pending = yield* waitForPending(2)
-    expect(pending.length).toBe(2)
-    yield* rejectAll
-    expect((yield* Fiber.await(fiber1))._tag).toBe("Failure")
-    expect((yield* Fiber.await(fiber2))._tag).toBe("Failure")
-  }),
-  { git: true },
-)
+      const pending = await list()
+      expect(pending.length).toBe(2)
+      await rejectAll()
+      p1.catch(() => {})
+      p2.catch(() => {})
+    },
+  })
+})

-it.instance("list - returns empty when no pending", () =>
-  Effect.gen(function* () {
-    const pending = yield* listEffect
-    expect(pending.length).toBe(0)
-  }),
-  { git: true },
-)
+test("list - returns empty when no pending", async () => {
+  await using tmp = await tmpdir({ git: true })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const pending = await list()
+      expect(pending.length).toBe(0)
+    },
+  })
+})

-it.live("questions stay isolated by directory", () =>
-  Effect.gen(function* () {
-    const one = yield* tmpdirScoped({ git: true })
-    const two = yield* tmpdirScoped({ git: true })
+test("questions stay isolated by directory", async () => {
+  await using one = await tmpdir({ git: true })
+  await using two = await tmpdir({ git: true })

-    const fiber1 = yield* askEffect({
-      sessionID: SessionID.make("ses_one"),
-      questions: [
-        {
-          question: "Question 1?",
-          header: "Q1",
-          options: [{ label: "A", description: "A" }],
-        },
-      ],
-    }).pipe(provideInstance(one), Effect.forkScoped)
+  const p1 = Instance.provide({
+    directory: one.path,
+    fn: () =>
+      ask({
+        sessionID: SessionID.make("ses_one"),
+        questions: [
+          {
+            question: "Question 1?",
+            header: "Q1",
+            options: [{ label: "A", description: "A" }],
+          },
+        ],
+      }),
+  })

-    const fiber2 = yield* askEffect({
-      sessionID: SessionID.make("ses_two"),
-      questions: [
-        {
-          question: "Question 2?",
-          header: "Q2",
-          options: [{ label: "B", description: "B" }],
-        },
-      ],
-    }).pipe(provideInstance(two), Effect.forkScoped)
+  const p2 = Instance.provide({
+    directory: two.path,
+    fn: () =>
+      ask({
+        sessionID: SessionID.make("ses_two"),
+        questions: [
+          {
+            question: "Question 2?",
+            header: "Q2",
+            options: [{ label: "B", description: "B" }],
+          },
+        ],
+      }),
+  })

-    const onePending = yield* waitForPending(1).pipe(provideInstance(one))
-    const twoPending = yield* waitForPending(1).pipe(provideInstance(two))
+  const onePending = await Instance.provide({
+    directory: one.path,
+    fn: () => list(),
+  })
+  const twoPending = await Instance.provide({
+    directory: two.path,
+    fn: () => list(),
+  })

-    expect(onePending.length).toBe(1)
-    expect(twoPending.length).toBe(1)
-    expect(onePending[0].sessionID).toBe(SessionID.make("ses_one"))
-    expect(twoPending[0].sessionID).toBe(SessionID.make("ses_two"))
+  expect(onePending.length).toBe(1)
+  expect(twoPending.length).toBe(1)
+  expect(onePending[0].sessionID).toBe(SessionID.make("ses_one"))
+  expect(twoPending[0].sessionID).toBe(SessionID.make("ses_two"))

-    yield* rejectEffect(onePending[0].id).pipe(provideInstance(one))
-    yield* rejectEffect(twoPending[0].id).pipe(provideInstance(two))
+  await Instance.provide({
+    directory: one.path,
+    fn: () => reject(onePending[0].id),
+  })
+  await Instance.provide({
+    directory: two.path,
+    fn: () => reject(twoPending[0].id),
+  })

-    expect((yield* Fiber.await(fiber1))._tag).toBe("Failure")
-    expect((yield* Fiber.await(fiber2))._tag).toBe("Failure")
-  }),
-)
+  await p1.catch(() => {})
+  await p2.catch(() => {})
+})

-it.live("pending question rejects on instance dispose", () =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped({ git: true })
-    const fiber = yield* askEffect({
-      sessionID: SessionID.make("ses_dispose"),
-      questions: [
-        {
-          question: "Dispose me?",
-          header: "Dispose",
-          options: [{ label: "Yes", description: "Yes" }],
-        },
-      ],
-    }).pipe(provideInstance(dir), Effect.forkScoped)
+test("pending question rejects on instance dispose", async () => {
+  await using tmp = await tmpdir({ git: true })

-    expect(yield* waitForPending(1).pipe(provideInstance(dir))).toHaveLength(1)
-    yield* Effect.promise(() => Instance.provide({ directory: dir, fn: () => void Instance.dispose() }))
+  const pending = Instance.provide({
+    directory: tmp.path,
+    fn: () => {
+      return ask({
+        sessionID: SessionID.make("ses_dispose"),
+        questions: [
+          {
+            question: "Dispose me?",
+            header: "Dispose",
+            options: [{ label: "Yes", description: "Yes" }],
+          },
+        ],
+      })
+    },
+  })
+  const result = pending.then(
+    () => "resolved" as const,
+    (err) => err,
+  )

-    const exit = yield* Fiber.await(fiber)
-    expect(Exit.isFailure(exit)).toBe(true)
-    if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Question.RejectedError)
-  }),
-)
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const items = await list()
+      expect(items).toHaveLength(1)
+      await Instance.dispose()
+    },
+  })

-it.live("pending question rejects on instance reload", () =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped({ git: true })
-    const fiber = yield* askEffect({
-      sessionID: SessionID.make("ses_reload"),
-      questions: [
-        {
-          question: "Reload me?",
-          header: "Reload",
-          options: [{ label: "Yes", description: "Yes" }],
-        },
-      ],
-    }).pipe(provideInstance(dir), Effect.forkScoped)
+  expect(await result).toBeInstanceOf(Question.RejectedError)
+})

-    expect(yield* waitForPending(1).pipe(provideInstance(dir))).toHaveLength(1)
-    yield* Effect.promise(() => Instance.reload({ directory: dir }))
+test("pending question rejects on instance reload", async () => {
+  await using tmp = await tmpdir({ git: true })

-    const exit = yield* Fiber.await(fiber)
-    expect(Exit.isFailure(exit)).toBe(true)
-    if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Question.RejectedError)
-  }),
-)
+  const pending = Instance.provide({
+    directory: tmp.path,
+    fn: () => {
+      return ask({
+        sessionID: SessionID.make("ses_reload"),
+        questions: [
+          {
+            question: "Reload me?",
+            header: "Reload",
+            options: [{ label: "Yes", description: "Yes" }],
+          },
+        ],
+      })
+    },
+  })
+  const result = pending.then(
+    () => "resolved" as const,
+    (err) => err,
+  )
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const items = await list()
+      expect(items).toHaveLength(1)
+      await Instance.reload({ directory: tmp.path })
+    },
+  })
+
+  expect(await result).toBeInstanceOf(Question.RejectedError)
+})
--- a/packages/opencode/test/server/global-bus.ts
+++ b/packages/opencode/test/server/global-bus.ts
@@ -1,34 +0,0 @@
-import { GlobalBus, type GlobalEvent } from "@/bus/global"
-import { Cause, Effect } from "effect"
-
-export function waitGlobalBusEvent(input: {
-  timeout?: number
-  message?: string
-  predicate: (event: GlobalEvent) => boolean
-}) {
-  return Effect.callback<GlobalEvent, unknown>((resume) => {
-    const cleanup = () => GlobalBus.off("event", handler)
-
-    const handler = (event: GlobalEvent) => {
-      try {
-        if (!input.predicate(event)) return
-        cleanup()
-        resume(Effect.succeed(event))
-      } catch (error) {
-        cleanup()
-        resume(Effect.fail(error))
-      }
-    }
-
-    GlobalBus.on("event", handler)
-    return Effect.sync(cleanup)
-  }).pipe(
-    Effect.timeout(input.timeout ?? 10_000),
-    Effect.mapError((error) =>
-      Cause.isTimeoutError(error) ? new Error(input.message ?? "timed out waiting for global bus event") : error,
-    ),
-  )
-}
-
-export const waitGlobalBusEventPromise = (input: Parameters<typeof waitGlobalBusEvent>[0]) =>
-  Effect.runPromise(waitGlobalBusEvent(input))
--- a/packages/opencode/test/server/httpapi-config.test.ts
+++ b/packages/opencode/test/server/httpapi-config.test.ts
@@ -1,11 +1,12 @@
 import { afterEach, describe, expect, test } from "bun:test"
 import path from "path"
 import { Flag } from "@opencode-ai/core/flag/flag"
+import { GlobalBus } from "@/bus/global"
+import { Instance } from "../../src/project/instance"
 import { Server } from "../../src/server/server"
 import * as Log from "@opencode-ai/core/util/log"
 import { resetDatabase } from "../fixture/db"
 import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import { waitGlobalBusEventPromise } from "./global-bus"

 void Log.init({ print: false })

@@ -17,9 +18,20 @@ function app() {
 }

 async function waitDisposed(directory: string) {
-  await waitGlobalBusEventPromise({
-    message: "timed out waiting for instance disposal",
-    predicate: (event) => event.payload.type === "server.instance.disposed" && event.directory === directory,
+  return await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      GlobalBus.off("event", onEvent)
+      reject(new Error("timed out waiting for instance disposal"))
+    }, 10_000)
+
+    function onEvent(event: { directory?: string; payload: { type?: string } }) {
+      if (event.payload.type !== "server.instance.disposed" || event.directory !== directory) return
+      clearTimeout(timer)
+      GlobalBus.off("event", onEvent)
+      resolve()
+    }
+
+    GlobalBus.on("event", onEvent)
  })
 }

--- a/packages/opencode/test/server/httpapi-experimental.test.ts
+++ b/packages/opencode/test/server/httpapi-experimental.test.ts
@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { Flag } from "@opencode-ai/core/flag/flag"
+import { GlobalBus } from "@/bus/global"
 import { Instance } from "../../src/project/instance"
 import { Server } from "../../src/server/server"
 import { ExperimentalPaths } from "../../src/server/routes/instance/httpapi/groups/experimental"
@@ -10,7 +11,6 @@ import * as Log from "@opencode-ai/core/util/log"
 import { Worktree } from "../../src/worktree"
 import { resetDatabase } from "../fixture/db"
 import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import { waitGlobalBusEventPromise } from "./global-bus"

 void Log.init({ print: false })

@@ -31,9 +31,20 @@ function createSession(input?: Session.CreateInput) {
 }

 async function waitReady(directory: string) {
-  await waitGlobalBusEventPromise({
-    message: "timed out waiting for worktree.ready",
-    predicate: (event) => event.payload.type === Worktree.Event.Ready.type && event.directory === directory,
+  return await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      GlobalBus.off("event", onEvent)
+      reject(new Error("timed out waiting for worktree.ready"))
+    }, 10_000)
+
+    function onEvent(event: { directory?: string; payload: { type?: string } }) {
+      if (event.payload.type !== Worktree.Event.Ready.type || event.directory !== directory) return
+      clearTimeout(timer)
+      GlobalBus.off("event", onEvent)
+      resolve()
+    }
+
+    GlobalBus.on("event", onEvent)
  })
 }

--- a/packages/opencode/test/server/httpapi-instance-context.test.ts
+++ b/packages/opencode/test/server/httpapi-instance-context.test.ts
@@ -1,5 +1,6 @@
 import { NodeHttpServer, NodeServices } from "@effect/platform-node"
 import { Flag } from "@opencode-ai/core/flag/flag"
+import { GlobalBus } from "@/bus/global"
 import { describe, expect } from "bun:test"
 import { Effect, Fiber, Layer } from "effect"
 import { HttpClient, HttpClientRequest, HttpRouter, HttpServerResponse } from "effect/unstable/http"
@@ -19,7 +20,6 @@ import { instanceRouterMiddleware } from "../../src/server/routes/instance/httpa
 import { workspaceRouterMiddleware } from "../../src/server/routes/instance/httpapi/middleware/workspace-routing"
 import { resetDatabase } from "../fixture/db"
 import { disposeAllInstances, tmpdirScoped } from "../fixture/fixture"
-import { waitGlobalBusEvent } from "./global-bus"
 import { testEffect } from "../lib/effect"

 const testStateLayer = Layer.effectDiscard(
@@ -97,10 +97,24 @@ const serveProbe = (probePath: HttpRouter.PathInput = "/probe") =>
    Layer.build,
  )

-const waitDisposedEvent = waitGlobalBusEvent({
-  message: "timed out waiting for instance disposal",
-  predicate: (event) => event.payload.type === "server.instance.disposed",
-}).pipe(Effect.map((event) => ({ directory: event.directory, workspace: event.workspace })))
+const waitDisposedEvent = Effect.promise(
+  () =>
+    new Promise<{ directory?: string; workspace?: string }>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        GlobalBus.off("event", onEvent)
+        reject(new Error("timed out waiting for instance disposal"))
+      }, 10_000)
+
+      function onEvent(event: { directory?: string; workspace?: string; payload: { type?: string } }) {
+        if (event.payload.type !== "server.instance.disposed") return
+        clearTimeout(timer)
+        GlobalBus.off("event", onEvent)
+        resolve({ directory: event.directory, workspace: event.workspace })
+      }
+
+      GlobalBus.on("event", onEvent)
+    }),
+)

 const serveDisposeProbe = () =>
  HttpRouter.serve(
--- a/packages/opencode/test/server/httpapi-instance.legacy.test.ts
+++ b/packages/opencode/test/server/httpapi-instance.legacy.test.ts
@@ -1,11 +1,12 @@
 import { afterEach, describe, expect, test } from "bun:test"
 import { Flag } from "@opencode-ai/core/flag/flag"
+import { GlobalBus } from "@/bus/global"
+import { Instance } from "../../src/project/instance"
 import { Server } from "../../src/server/server"
 import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
 import * as Log from "@opencode-ai/core/util/log"
 import { resetDatabase } from "../fixture/db"
 import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import { waitGlobalBusEventPromise } from "./global-bus"

 void Log.init({ print: false })

@@ -17,9 +18,20 @@ function app() {
 }

 async function waitDisposed(directory: string) {
-  await waitGlobalBusEventPromise({
-    message: "timed out waiting for instance disposal",
-    predicate: (event) => event.payload.type === "server.instance.disposed" && event.directory === directory,
+  return await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      GlobalBus.off("event", onEvent)
+      reject(new Error("timed out waiting for instance disposal"))
+    }, 10_000)
+
+    function onEvent(event: { directory?: string; payload: { type?: string } }) {
+      if (event.payload.type !== "server.instance.disposed" || event.directory !== directory) return
+      clearTimeout(timer)
+      GlobalBus.off("event", onEvent)
+      resolve()
+    }
+
+    GlobalBus.on("event", onEvent)
  })
 }

@@ -105,9 +117,13 @@ describe("instance HttpApi", () => {
  test("serves instance dispose through Hono bridge", async () => {
    await using tmp = await tmpdir()

-    const disposed = waitGlobalBusEventPromise({
-      message: "timed out waiting for instance disposal",
-      predicate: (event) => event.payload.type === "server.instance.disposed",
+    const disposed = new Promise<string | undefined>((resolve) => {
+      const onEvent = (event: { directory?: string; payload: { type?: string } }) => {
+        if (event.payload.type !== "server.instance.disposed") return
+        GlobalBus.off("event", onEvent)
+        resolve(event.directory)
+      }
+      GlobalBus.on("event", onEvent)
    })

    const response = await app().request(InstancePaths.dispose, {
@@ -117,6 +133,6 @@ describe("instance HttpApi", () => {

    expect(response.status).toBe(200)
    expect(await response.json()).toBe(true)
-    expect((await disposed).directory).toBe(tmp.path)
+    expect(await disposed).toBe(tmp.path)
  })
 })
--- a/packages/opencode/test/server/httpapi-tui.test.ts
+++ b/packages/opencode/test/server/httpapi-tui.test.ts
@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test"
 import type { Context } from "hono"
 import { Flag } from "@opencode-ai/core/flag/flag"
+import { GlobalBus } from "../../src/bus/global"
 import { TuiEvent } from "../../src/cli/cmd/tui/event"
 import { SessionID } from "../../src/session/schema"
 import { Instance } from "../../src/project/instance"
@@ -11,7 +12,6 @@ import * as Log from "@opencode-ai/core/util/log"
 import { OpenApi } from "effect/unstable/httpapi"
 import { resetDatabase } from "../fixture/db"
 import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import { waitGlobalBusEventPromise } from "./global-bus"

 void Log.init({ print: false })

@@ -23,9 +23,14 @@ function app(experimental = true) {
 }

 function nextCommandExecute() {
-  return waitGlobalBusEventPromise({
-    predicate: (event) => event.payload.type === TuiEvent.CommandExecute.type,
-  }).then((event) => event.payload.properties?.command)
+  return new Promise<unknown>((resolve) => {
+    const listener = (event: { payload: { type?: string; properties?: { command?: unknown } } }) => {
+      if (event.payload.type !== TuiEvent.CommandExecute.type) return
+      GlobalBus.off("event", listener)
+      resolve(event.payload.properties?.command)
+    }
+    GlobalBus.on("event", listener)
+  })
 }

 async function expectTrue(path: string, headers: Record<string, string>, body?: unknown) {
--- a/packages/opencode/test/tool/glob.test.ts
+++ b/packages/opencode/test/tool/glob.test.ts
@@ -8,7 +8,7 @@ import { Ripgrep } from "../../src/file/ripgrep"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { Truncate } from "@/tool/truncate"
 import { Agent } from "../../src/agent/agent"
-import { TestInstance } from "../fixture/fixture"
+import { provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"

 const it = testEffect(
@@ -33,47 +33,49 @@ const ctx = {
 }

 describe("tool.glob", () => {
-  it.instance("matches files from a directory path", () =>
-    Effect.gen(function* () {
-      const test = yield* TestInstance
-      yield* Effect.promise(() => Bun.write(path.join(test.directory, "a.ts"), "export const a = 1\n"))
-      yield* Effect.promise(() => Bun.write(path.join(test.directory, "b.txt"), "hello\n"))
-      const info = yield* GlobTool
-      const glob = yield* info.init()
-      const result = yield* glob.execute(
-        {
-          pattern: "*.ts",
-          path: test.directory,
-        },
-        ctx,
-      )
-      expect(result.metadata.count).toBe(1)
-      expect(result.output).toContain(path.join(test.directory, "a.ts"))
-      expect(result.output).not.toContain(path.join(test.directory, "b.txt"))
-    }),
-  )
-
-  it.instance("rejects exact file paths", () =>
-    Effect.gen(function* () {
-      const test = yield* TestInstance
-      const file = path.join(test.directory, "a.ts")
-      yield* Effect.promise(() => Bun.write(file, "export const a = 1\n"))
-      const info = yield* GlobTool
-      const glob = yield* info.init()
-      const exit = yield* glob
-        .execute(
+  it.live("matches files from a directory path", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => Bun.write(path.join(dir, "a.ts"), "export const a = 1\n"))
+        yield* Effect.promise(() => Bun.write(path.join(dir, "b.txt"), "hello\n"))
+        const info = yield* GlobTool
+        const glob = yield* info.init()
+        const result = yield* glob.execute(
          {
            pattern: "*.ts",
-            path: file,
+            path: dir,
          },
          ctx,
        )
-        .pipe(Effect.exit)
-      expect(Exit.isFailure(exit)).toBe(true)
-      if (Exit.isFailure(exit)) {
-        const err = Cause.squash(exit.cause)
-        expect(err instanceof Error ? err.message : String(err)).toContain("glob path must be a directory")
-      }
-    }),
+        expect(result.metadata.count).toBe(1)
+        expect(result.output).toContain(path.join(dir, "a.ts"))
+        expect(result.output).not.toContain(path.join(dir, "b.txt"))
+      }),
+    ),
+  )
+
+  it.live("rejects exact file paths", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        const file = path.join(dir, "a.ts")
+        yield* Effect.promise(() => Bun.write(file, "export const a = 1\n"))
+        const info = yield* GlobTool
+        const glob = yield* info.init()
+        const exit = yield* glob
+          .execute(
+            {
+              pattern: "*.ts",
+              path: file,
+            },
+            ctx,
+          )
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(exit)).toBe(true)
+        if (Exit.isFailure(exit)) {
+          const err = Cause.squash(exit.cause)
+          expect(err instanceof Error ? err.message : String(err)).toContain("glob path must be a directory")
+        }
+      }),
+    ),
  )
 })
--- a/packages/opencode/test/tool/grep.test.ts
+++ b/packages/opencode/test/tool/grep.test.ts
@@ -2,7 +2,7 @@ import { describe, expect } from "bun:test"
 import path from "path"
 import { Effect, Layer } from "effect"
 import { GrepTool } from "../../src/tool/grep"
-import { provideInstance, TestInstance } from "../fixture/fixture"
+import { provideInstance, provideTmpdirInstance } from "../fixture/fixture"
 import { SessionID, MessageID } from "../../src/session/schema"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { Truncate } from "@/tool/truncate"
@@ -54,58 +54,61 @@ describe("tool.grep", () => {
    }),
  )

-  it.instance("no matches returns correct output", () =>
-    Effect.gen(function* () {
-      const test = yield* TestInstance
-      yield* Effect.promise(() => Bun.write(path.join(test.directory, "test.txt"), "hello world"))
-      const info = yield* GrepTool
-      const grep = yield* info.init()
-      const result = yield* grep.execute(
-        {
-          pattern: "xyznonexistentpatternxyz123",
-          path: test.directory,
-        },
-        ctx,
-      )
-      expect(result.metadata.matches).toBe(0)
-      expect(result.output).toBe("No files found")
-    }),
+  it.live("no matches returns correct output", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => Bun.write(path.join(dir, "test.txt"), "hello world"))
+        const info = yield* GrepTool
+        const grep = yield* info.init()
+        const result = yield* grep.execute(
+          {
+            pattern: "xyznonexistentpatternxyz123",
+            path: dir,
+          },
+          ctx,
+        )
+        expect(result.metadata.matches).toBe(0)
+        expect(result.output).toBe("No files found")
+      }),
+    ),
  )

-  it.instance("finds matches in tmp instance", () =>
-    Effect.gen(function* () {
-      const test = yield* TestInstance
-      yield* Effect.promise(() => Bun.write(path.join(test.directory, "test.txt"), "line1\nline2\nline3"))
-      const info = yield* GrepTool
-      const grep = yield* info.init()
-      const result = yield* grep.execute(
-        {
-          pattern: "line",
-          path: test.directory,
-        },
-        ctx,
-      )
-      expect(result.metadata.matches).toBeGreaterThan(0)
-    }),
+  it.live("finds matches in tmp instance", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => Bun.write(path.join(dir, "test.txt"), "line1\nline2\nline3"))
+        const info = yield* GrepTool
+        const grep = yield* info.init()
+        const result = yield* grep.execute(
+          {
+            pattern: "line",
+            path: dir,
+          },
+          ctx,
+        )
+        expect(result.metadata.matches).toBeGreaterThan(0)
+      }),
+    ),
  )

-  it.instance("supports exact file paths", () =>
-    Effect.gen(function* () {
-      const test = yield* TestInstance
-      const file = path.join(test.directory, "test.txt")
-      yield* Effect.promise(() => Bun.write(file, "line1\nline2\nline3"))
-      const info = yield* GrepTool
-      const grep = yield* info.init()
-      const result = yield* grep.execute(
-        {
-          pattern: "line2",
-          path: file,
-        },
-        ctx,
-      )
-      expect(result.metadata.matches).toBe(1)
-      expect(result.output).toContain(file)
-      expect(result.output).toContain("Line 2: line2")
-    }),
+  it.live("supports exact file paths", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        const file = path.join(dir, "test.txt")
+        yield* Effect.promise(() => Bun.write(file, "line1\nline2\nline3"))
+        const info = yield* GrepTool
+        const grep = yield* info.init()
+        const result = yield* grep.execute(
+          {
+            pattern: "line2",
+            path: file,
+          },
+          ctx,
+        )
+        expect(result.metadata.matches).toBe(1)
+        expect(result.output).toContain(file)
+        expect(result.output).toContain("Line 2: line2")
+      }),
+    ),
  )
 })
--- a/packages/opencode/test/tool/question.test.ts
+++ b/packages/opencode/test/tool/question.test.ts
@@ -6,6 +6,7 @@ import { SessionID, MessageID } from "../../src/session/schema"
 import { Agent } from "../../src/agent/agent"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { Truncate } from "@/tool/truncate"
+import { provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"

 const ctx = {
@@ -33,52 +34,56 @@ const pending = Effect.fn("QuestionToolTest.pending")(function* (question: Quest
 })

 describe("tool.question", () => {
-  it.instance("should successfully execute with valid question parameters", () =>
-    Effect.gen(function* () {
-      const question = yield* Question.Service
-      const toolInfo = yield* QuestionTool
-      const tool = yield* toolInfo.init()
-      const questions = [
-        {
-          question: "What is your favorite color?",
-          header: "Color",
-          options: [
-            { label: "Red", description: "The color of passion" },
-            { label: "Blue", description: "The color of sky" },
-          ],
-          multiple: false,
-        },
-      ]
+  it.live("should successfully execute with valid question parameters", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const question = yield* Question.Service
+        const toolInfo = yield* QuestionTool
+        const tool = yield* toolInfo.init()
+        const questions = [
+          {
+            question: "What is your favorite color?",
+            header: "Color",
+            options: [
+              { label: "Red", description: "The color of passion" },
+              { label: "Blue", description: "The color of sky" },
+            ],
+            multiple: false,
+          },
+        ]

-      const fiber = yield* tool.execute({ questions }, ctx).pipe(Effect.forkScoped)
-      const item = yield* pending(question)
-      yield* question.reply({ requestID: item.id, answers: [["Red"]] })
+        const fiber = yield* tool.execute({ questions }, ctx).pipe(Effect.forkScoped)
+        const item = yield* pending(question)
+        yield* question.reply({ requestID: item.id, answers: [["Red"]] })

-      const result = yield* Fiber.join(fiber)
-      expect(result.title).toBe("Asked 1 question")
-    }),
+        const result = yield* Fiber.join(fiber)
+        expect(result.title).toBe("Asked 1 question")
+      }),
+    ),
  )

-  it.instance("should now pass with a header longer than 12 but less than 30 chars", () =>
-    Effect.gen(function* () {
-      const question = yield* Question.Service
-      const toolInfo = yield* QuestionTool
-      const tool = yield* toolInfo.init()
-      const questions = [
-        {
-          question: "What is your favorite animal?",
-          header: "This Header is Over 12",
-          options: [{ label: "Dog", description: "Man's best friend" }],
-        },
-      ]
+  it.live("should now pass with a header longer than 12 but less than 30 chars", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const question = yield* Question.Service
+        const toolInfo = yield* QuestionTool
+        const tool = yield* toolInfo.init()
+        const questions = [
+          {
+            question: "What is your favorite animal?",
+            header: "This Header is Over 12",
+            options: [{ label: "Dog", description: "Man's best friend" }],
+          },
+        ]

-      const fiber = yield* tool.execute({ questions }, ctx).pipe(Effect.forkScoped)
-      const item = yield* pending(question)
-      yield* question.reply({ requestID: item.id, answers: [["Dog"]] })
+        const fiber = yield* tool.execute({ questions }, ctx).pipe(Effect.forkScoped)
+        const item = yield* pending(question)
+        yield* question.reply({ requestID: item.id, answers: [["Dog"]] })

-      const result = yield* Fiber.join(fiber)
-      expect(result.output).toContain(`"What is your favorite animal?"="Dog"`)
-    }),
+        const result = yield* Fiber.join(fiber)
+        expect(result.output).toContain(`"What is your favorite animal?"="Dog"`)
+      }),
+    ),
  )

  // intentionally removed the zod validation due to tool call errors, hoping prompting is gonna be good enough
--- a/packages/opencode/test/tool/registry.test.ts
+++ b/packages/opencode/test/tool/registry.test.ts
@@ -2,9 +2,10 @@ import { afterEach, describe, expect } from "bun:test"
 import path from "path"
 import fs from "fs/promises"
 import { Effect, Layer } from "effect"
+import { Instance } from "../../src/project/instance"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { ToolRegistry } from "@/tool/registry"
-import { disposeAllInstances, TestInstance } from "../fixture/fixture"
+import { disposeAllInstances, provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"

 const node = CrossSpawnSpawner.defaultLayer
@@ -16,133 +17,136 @@ afterEach(async () => {
 })

 describe("tool.registry", () => {
-  it.instance("loads tools from .opencode/tool (singular)", () =>
-    Effect.gen(function* () {
-      const test = yield* TestInstance
-      const opencode = path.join(test.directory, ".opencode")
-      const tool = path.join(opencode, "tool")
-      yield* Effect.promise(() => fs.mkdir(tool, { recursive: true }))
-      yield* Effect.promise(() =>
-        Bun.write(
-          path.join(tool, "hello.ts"),
-          [
-            "export default {",
-            "  description: 'hello tool',",
-            "  args: {},",
-            "  execute: async () => {",
-            "    return 'hello world'",
-            "  },",
-            "}",
-            "",
-          ].join("\n"),
-        ),
-      )
-      const registry = yield* ToolRegistry.Service
-      const ids = yield* registry.ids()
-      expect(ids).toContain("hello")
-    }),
+  it.live("loads tools from .opencode/tool (singular)", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        const opencode = path.join(dir, ".opencode")
+        const tool = path.join(opencode, "tool")
+        yield* Effect.promise(() => fs.mkdir(tool, { recursive: true }))
+        yield* Effect.promise(() =>
+          Bun.write(
+            path.join(tool, "hello.ts"),
+            [
+              "export default {",
+              "  description: 'hello tool',",
+              "  args: {},",
+              "  execute: async () => {",
+              "    return 'hello world'",
+              "  },",
+              "}",
+              "",
+            ].join("\n"),
+          ),
+        )
+        const registry = yield* ToolRegistry.Service
+        const ids = yield* registry.ids()
+        expect(ids).toContain("hello")
+      }),
+    ),
  )

-  it.instance("loads tools from .opencode/tools (plural)", () =>
-    Effect.gen(function* () {
-      const test = yield* TestInstance
-      const opencode = path.join(test.directory, ".opencode")
-      const tools = path.join(opencode, "tools")
-      yield* Effect.promise(() => fs.mkdir(tools, { recursive: true }))
-      yield* Effect.promise(() =>
-        Bun.write(
-          path.join(tools, "hello.ts"),
-          [
-            "export default {",
-            "  description: 'hello tool',",
-            "  args: {},",
-            "  execute: async () => {",
-            "    return 'hello world'",
-            "  },",
-            "}",
-            "",
-          ].join("\n"),
-        ),
-      )
-      const registry = yield* ToolRegistry.Service
-      const ids = yield* registry.ids()
-      expect(ids).toContain("hello")
-    }),
+  it.live("loads tools from .opencode/tools (plural)", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        const opencode = path.join(dir, ".opencode")
+        const tools = path.join(opencode, "tools")
+        yield* Effect.promise(() => fs.mkdir(tools, { recursive: true }))
+        yield* Effect.promise(() =>
+          Bun.write(
+            path.join(tools, "hello.ts"),
+            [
+              "export default {",
+              "  description: 'hello tool',",
+              "  args: {},",
+              "  execute: async () => {",
+              "    return 'hello world'",
+              "  },",
+              "}",
+              "",
+            ].join("\n"),
+          ),
+        )
+        const registry = yield* ToolRegistry.Service
+        const ids = yield* registry.ids()
+        expect(ids).toContain("hello")
+      }),
+    ),
  )

-  it.instance("loads tools with external dependencies without crashing", () =>
-    Effect.gen(function* () {
-      const test = yield* TestInstance
-      const opencode = path.join(test.directory, ".opencode")
-      const tools = path.join(opencode, "tools")
-      yield* Effect.promise(() => fs.mkdir(tools, { recursive: true }))
-      yield* Effect.promise(() =>
-        Bun.write(
-          path.join(opencode, "package.json"),
-          JSON.stringify({
-            name: "custom-tools",
-            dependencies: {
-              "@opencode-ai/plugin": "^0.0.0",
-              cowsay: "^1.6.0",
-            },
-          }),
-        ),
-      )
-      yield* Effect.promise(() =>
-        Bun.write(
-          path.join(opencode, "package-lock.json"),
-          JSON.stringify({
-            name: "custom-tools",
-            lockfileVersion: 3,
-            packages: {
-              "": {
-                dependencies: {
-                  "@opencode-ai/plugin": "^0.0.0",
-                  cowsay: "^1.6.0",
+  it.live("loads tools with external dependencies without crashing", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        const opencode = path.join(dir, ".opencode")
+        const tools = path.join(opencode, "tools")
+        yield* Effect.promise(() => fs.mkdir(tools, { recursive: true }))
+        yield* Effect.promise(() =>
+          Bun.write(
+            path.join(opencode, "package.json"),
+            JSON.stringify({
+              name: "custom-tools",
+              dependencies: {
+                "@opencode-ai/plugin": "^0.0.0",
+                cowsay: "^1.6.0",
+              },
+            }),
+          ),
+        )
+        yield* Effect.promise(() =>
+          Bun.write(
+            path.join(opencode, "package-lock.json"),
+            JSON.stringify({
+              name: "custom-tools",
+              lockfileVersion: 3,
+              packages: {
+                "": {
+                  dependencies: {
+                    "@opencode-ai/plugin": "^0.0.0",
+                    cowsay: "^1.6.0",
+                  },
                },
              },
-            },
-          }),
-        ),
-      )
+            }),
+          ),
+        )

-      const cowsay = path.join(opencode, "node_modules", "cowsay")
-      yield* Effect.promise(() => fs.mkdir(cowsay, { recursive: true }))
-      yield* Effect.promise(() =>
-        Bun.write(
-          path.join(cowsay, "package.json"),
-          JSON.stringify({
-            name: "cowsay",
-            type: "module",
-            exports: "./index.js",
-          }),
-        ),
-      )
-      yield* Effect.promise(() =>
-        Bun.write(
-          path.join(cowsay, "index.js"),
-          ["export function say({ text }) {", "  return `moo ${text}`", "}", ""].join("\n"),
-        ),
-      )
-      yield* Effect.promise(() =>
-        Bun.write(
-          path.join(tools, "cowsay.ts"),
-          [
-            "import { say } from 'cowsay'",
-            "export default {",
-            "  description: 'tool that imports cowsay at top level',",
-            "  args: { text: { type: 'string' } },",
-            "  execute: async ({ text }: { text: string }) => {",
-            "    return say({ text })",
-            "  },",
-            "}",
-            "",
-          ].join("\n"),
-        ),
-      )
-      const registry = yield* ToolRegistry.Service
-      const ids = yield* registry.ids()
-      expect(ids).toContain("cowsay")
-    }),
+        const cowsay = path.join(opencode, "node_modules", "cowsay")
+        yield* Effect.promise(() => fs.mkdir(cowsay, { recursive: true }))
+        yield* Effect.promise(() =>
+          Bun.write(
+            path.join(cowsay, "package.json"),
+            JSON.stringify({
+              name: "cowsay",
+              type: "module",
+              exports: "./index.js",
+            }),
+          ),
+        )
+        yield* Effect.promise(() =>
+          Bun.write(
+            path.join(cowsay, "index.js"),
+            ["export function say({ text }) {", "  return `moo ${text}`", "}", ""].join("\n"),
+          ),
+        )
+        yield* Effect.promise(() =>
+          Bun.write(
+            path.join(tools, "cowsay.ts"),
+            [
+              "import { say } from 'cowsay'",
+              "export default {",
+              "  description: 'tool that imports cowsay at top level',",
+              "  args: { text: { type: 'string' } },",
+              "  execute: async ({ text }: { text: string }) => {",
+              "    return say({ text })",
+              "  },",
+              "}",
+              "",
+            ].join("\n"),
+          ),
+        )
+        const registry = yield* ToolRegistry.Service
+        const ids = yield* registry.ids()
+        expect(ids).toContain("cowsay")
+      }),
+    ),
  )
 })
--- a/packages/opencode/test/tool/write.test.ts
+++ b/packages/opencode/test/tool/write.test.ts
@@ -13,7 +13,7 @@ import { Tool } from "@/tool/tool"
 import { Agent } from "../../src/agent/agent"
 import { SessionID, MessageID } from "../../src/session/schema"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
-import { disposeAllInstances, provideTmpdirInstance, TestInstance } from "../fixture/fixture"
+import { disposeAllInstances, provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"

 const ctx = {
@@ -58,39 +58,42 @@ const run = Effect.fn("WriteToolTest.run")(function* (

 describe("tool.write", () => {
  describe("new file creation", () => {
-    it.instance("writes content to new file", () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const filepath = path.join(test.directory, "newfile.txt")
-        const result = yield* run({ filePath: filepath, content: "Hello, World!" })
+    it.live("writes content to new file", () =>
+      provideTmpdirInstance((dir) =>
+        Effect.gen(function* () {
+          const filepath = path.join(dir, "newfile.txt")
+          const result = yield* run({ filePath: filepath, content: "Hello, World!" })

-        expect(result.output).toContain("Wrote file successfully")
-        expect(result.metadata.exists).toBe(false)
+          expect(result.output).toContain("Wrote file successfully")
+          expect(result.metadata.exists).toBe(false)

-        const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
-        expect(content).toBe("Hello, World!")
-      }),
+          const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
+          expect(content).toBe("Hello, World!")
+        }),
+      ),
    )

-    it.instance("creates parent directories if needed", () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const filepath = path.join(test.directory, "nested", "deep", "file.txt")
-        yield* run({ filePath: filepath, content: "nested content" })
+    it.live("creates parent directories if needed", () =>
+      provideTmpdirInstance((dir) =>
+        Effect.gen(function* () {
+          const filepath = path.join(dir, "nested", "deep", "file.txt")
+          yield* run({ filePath: filepath, content: "nested content" })

-        const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
-        expect(content).toBe("nested content")
-      }),
+          const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
+          expect(content).toBe("nested content")
+        }),
+      ),
    )

-    it.instance("handles relative paths by resolving to instance directory", () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        yield* run({ filePath: "relative.txt", content: "relative content" })
+    it.live("handles relative paths by resolving to instance directory", () =>
+      provideTmpdirInstance((dir) =>
+        Effect.gen(function* () {
+          yield* run({ filePath: "relative.txt", content: "relative content" })

-        const content = yield* Effect.promise(() => fs.readFile(path.join(test.directory, "relative.txt"), "utf-8"))
-        expect(content).toBe("relative content")
-      }),
+          const content = yield* Effect.promise(() => fs.readFile(path.join(dir, "relative.txt"), "utf-8"))
+          expect(content).toBe("relative content")
+        }),
+      ),
    )
  })

--- a/packages/plugin/package.json
+++ b/packages/plugin/package.json
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode-ai/plugin",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "type": "module",
  "license": "MIT",
  "scripts": {
--- a/packages/sdk/js/package.json
+++ b/packages/sdk/js/package.json
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode-ai/sdk",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "type": "module",
  "license": "MIT",
  "scripts": {
--- a/packages/slack/package.json
+++ b/packages/slack/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/slack",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "type": "module",
  "license": "MIT",
  "scripts": {
--- a/packages/ui/package.json
+++ b/packages/ui/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/ui",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "type": "module",
  "license": "MIT",
  "exports": {
--- a/packages/web/package.json
+++ b/packages/web/package.json
@@ -2,7 +2,7 @@
  "name": "@opencode-ai/web",
  "type": "module",
  "license": "MIT",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "scripts": {
    "dev": "astro dev",
    "dev:remote": "VITE_API_URL=https://api.opencode.ai astro dev",
--- a/sdks/vscode/package.json
+++ b/sdks/vscode/package.json
@@ -2,7 +2,7 @@
  "name": "opencode",
  "displayName": "opencode",
  "description": "opencode for VS Code",
-  "version": "1.14.31",
+  "version": "1.14.32",
  "publisher": "sst-dev",
  "repository": {
    "type": "git",