test: migrate auth override plugin test

bun.lock

@@ -65,7 +65,6 @@
         "solid-list": "catalog:",
         "tailwindcss": "catalog:",
         "virtua": "catalog:",
-        "zod": "catalog:",
       },
       "devDependencies": {
         "@happy-dom/global-registrator": "20.0.11",
@@ -214,7 +213,6 @@
         "npm-package-arg": "13.0.2",
         "semver": "^7.6.3",
         "xdg-basedir": "5.1.0",
-        "zod": "catalog:",
       },
       "devDependencies": {
         "@tsconfig/bun": "catalog:",
@@ -396,7 +394,6 @@
         "@octokit/graphql": "9.0.2",
         "@octokit/rest": "catalog:",
         "@openauthjs/openauth": "catalog:",
-        "@opencode-ai/llm": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
         "@opencode-ai/script": "workspace:*",
         "@opencode-ai/sdk": "workspace:*",

bunfig.toml

@@ -1,6 +1,7 @@
 [install]
 exact = true
+# Only install newly resolved package versions published at least 3 days ago.
+minimumReleaseAge = 259200
 
 [test]
 root = "./do-not-run-tests-from-root"
-

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-Q9r1S15YL9LQK7DRhuOpw3Fxi24BPovEM995GZJayKw=",
-    "aarch64-linux": "sha256-C0rRTLnxxuuEkCBc3JZbkR66TUVwpcPFif3BU9GRAuA=",
-    "aarch64-darwin": "sha256-1HvalOO/pOkRlYH8CZ93psapt90C+pYzui1JCadBE1Q=",
-    "x86_64-darwin": "sha256-RrndyLWfhWm4mZ88XytFF2NI+ly8la550Z5LBN/g5u4="
+    "x86_64-linux": "sha256-MUHog06sZEi6bXR1m8exdkjSNW9bHEv9bPQXACJ7SFw=",
+    "aarch64-linux": "sha256-3dwdZ3It++OsdGT8xMOQ10Arz8eeODp/LXOrI4DLEhY=",
+    "aarch64-darwin": "sha256-TmUPGDCewjsrT13npVH6B55J43NKKut67p/HgPJpQNM=",
+    "x86_64-darwin": "sha256-j8I7t3MZoUQUMFRWyaFO75TRbAw5TauSZAa4yKOHFMA="
   }
 }

packages/app/package.json

@@ -73,7 +73,6 @@
     "solid-js": "catalog:",
     "solid-list": "catalog:",
     "tailwindcss": "catalog:",
-    "virtua": "catalog:",
-    "zod": "catalog:"
+    "virtua": "catalog:"
   }
 }

packages/app/src/context/global-sdk.tsx

@@ -3,15 +3,13 @@ import { createSimpleContext } from "@opencode-ai/ui/context"
 import { createGlobalEmitter } from "@solid-primitives/event-bus"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { batch, onCleanup, onMount } from "solid-js"
-import z from "zod"
 import { createSdkForServer } from "@/utils/server"
 import { useLanguage } from "./language"
 import { usePlatform } from "./platform"
 import { useServer } from "./server"
 
-const abortError = z.object({
-  name: z.literal("AbortError"),
-})
+const isAbortError = (error: unknown) =>
+  error !== null && typeof error === "object" && "name" in error && error.name === "AbortError"
 
 export const { use: useGlobalSDK, provider: GlobalSDKProvider } = createSimpleContext({
   name: "GlobalSDK",
@@ -103,7 +101,7 @@ export const { use: useGlobalSDK, provider: GlobalSDKProvider } = createSimpleCo
 
     let streamErrorLogged = false
     const wait = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms))
-    const aborted = (error: unknown) => abortError.safeParse(error).success
+    const aborted = isAbortError
 
     let attempt: AbortController | undefined
     let run: Promise<void> | undefined

packages/app/src/utils/id.ts

@@ -1,5 +1,3 @@
-import z from "zod"
-
 const prefixes = {
   session: "ses",
   message: "msg",
@@ -15,10 +13,6 @@ let counter = 0
 
 type Prefix = keyof typeof prefixes
 export namespace Identifier {
-  export function schema(prefix: Prefix) {
-    return z.string().startsWith(prefixes[prefix])
-  }
-
   export function ascending(prefix: Prefix, given?: string) {
     return generateID(prefix, false, given)
   }

packages/console/app/src/routes/zen/util/handler.ts

@@ -299,7 +299,6 @@ export async function handler(
         let buffer = ""
         let responseLength = 0
         let timestampFirstByte = 0
-        let timestampLastByte = 0
 
         function pump(): Promise<void> {
           return (

packages/core/package.json

@@ -41,8 +41,7 @@
     "minimatch": "10.2.5",
     "npm-package-arg": "13.0.2",
     "semver": "^7.6.3",
-    "xdg-basedir": "5.1.0",
-    "zod": "catalog:"
+    "xdg-basedir": "5.1.0"
   },
   "overrides": {
     "drizzle-orm": "catalog:"

packages/core/src/util/fn.ts

@@ -1,11 +0,0 @@
-import { z } from "zod"
-
-export function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) {
-  const result = (input: z.infer<T>) => {
-    const parsed = schema.parse(input)
-    return cb(parsed)
-  }
-  result.force = (input: z.infer<T>) => cb(input)
-  result.schema = schema
-  return result
-}

packages/core/src/util/log.ts

@@ -4,11 +4,14 @@ import path from "path"
 import fs from "fs/promises"
 import { createWriteStream } from "fs"
 import * as Global from "../global"
-import z from "zod"
+import { Schema } from "effect"
 import { Glob } from "./glob"
 
-export const Level = z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" })
-export type Level = z.infer<typeof Level>
+export const Level = Schema.Literals(["DEBUG", "INFO", "WARN", "ERROR"]).annotate({
+  identifier: "LogLevel",
+  description: "Log level",
+})
+export type Level = Schema.Schema.Type<typeof Level>
 
 const levelPriority: Record<Level, number> = {
   DEBUG: 0,

packages/enterprise/src/core/share.ts

@@ -1,9 +1,12 @@
 import { Message, Model, Part, Session, SnapshotFileDiff } from "@opencode-ai/sdk/v2"
-import { fn } from "@opencode-ai/core/util/fn"
 import { iife } from "@opencode-ai/core/util/iife"
 import z from "zod"
 import { Storage } from "./storage"
 
+function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) {
+  return (input: z.infer<T>) => cb(schema.parse(input))
+}
+
 export namespace Share {
   export const Info = z.object({
     id: z.string(),

packages/llm/example/tutorial.ts

@@ -78,7 +78,7 @@ const streamText = LLM.stream(request).pipe(
   Stream.tap((event) =>
     Effect.sync(() => {
       if (event.type === "text-delta") process.stdout.write(`\ntext: ${event.text}`)
-      if (event.type === "request-finish") process.stdout.write(`\nfinish: ${event.reason}\n`)
+      if (event.type === "finish") process.stdout.write(`\nfinish: ${event.reason}\n`)
     }),
   ),
   Stream.runDrain,
@@ -185,7 +185,7 @@ const FakeProtocol = Protocol.make<FakeBody, string, string, void>({
     event: Schema.String,
     initial: () => undefined,
     step: (_, frame) => Effect.succeed([undefined, [{ type: "text-delta", id: "text-0", text: frame }]] as const),
-    onHalt: () => [{ type: "request-finish", reason: "stop" }],
+    onHalt: () => [{ type: "finish", reason: "stop" }],
   },
 })
 

packages/llm/src/index.ts

@@ -17,6 +17,7 @@ export type {
   ExecutableTools,
   Tool as ToolShape,
   ToolExecute,
+  ToolExecuteContext,
   Tools,
   ToolSchema,
 } from "./tool"

packages/llm/src/protocols/openai-responses.ts

@@ -380,7 +380,7 @@ type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
 const NO_EVENTS: StepResult["1"] = []
 
 // `response.completed` / `response.incomplete` are clean finishes that emit a
-// `request-finish` event; `response.failed` is a hard failure that emits a
+// `finish` event; `response.failed` is a hard failure that emits a
 // `provider-error`. All three end the stream — kept in one set so `step` and
 // the protocol's `terminal` predicate stay in sync.
 const TERMINAL_TYPES = new Set(["response.completed", "response.incomplete", "response.failed"])

packages/llm/src/protocols/utils/lifecycle.ts

@@ -80,7 +80,7 @@ export const finish = (
       usage: input.usage,
       providerMetadata: input.providerMetadata,
     }),
-    LLMEvent.requestFinish(input),
+    LLMEvent.finish(input),
   )
   return { ...stepped, stepStarted: false }
 }

packages/llm/src/schema/events.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { ContentBlockID, FinishReason, ProtocolID, ProviderMetadata, ResponseID, RouteID, ToolCallID } from "./ids"
+import { ContentBlockID, FinishReason, ProtocolID, ProviderMetadata, RouteID, ToolCallID } from "./ids"
 import { ModelRef } from "./options"
 import { ToolResultValue } from "./messages"
 
@@ -66,14 +66,13 @@ export class Usage extends Schema.Class<Usage>("LLM.Usage")({
   get visibleOutputTokens() {
     return Math.max(0, (this.outputTokens ?? 0) - (this.reasoningTokens ?? 0))
   }
+
+  static from(input: UsageInput) {
+    return input instanceof Usage ? input : new Usage(input)
+  }
 }
 
-export const RequestStart = Schema.Struct({
-  type: Schema.tag("request-start"),
-  id: ResponseID,
-  model: ModelRef,
-}).annotate({ identifier: "LLM.Event.RequestStart" })
-export type RequestStart = Schema.Schema.Type<typeof RequestStart>
+export type UsageInput = Usage | ConstructorParameters<typeof Usage>[0]
 
 export const StepStart = Schema.Struct({
   type: Schema.tag("step-start"),
@@ -185,13 +184,13 @@ export const StepFinish = Schema.Struct({
 }).annotate({ identifier: "LLM.Event.StepFinish" })
 export type StepFinish = Schema.Schema.Type<typeof StepFinish>
 
-export const RequestFinish = Schema.Struct({
-  type: Schema.tag("request-finish"),
+export const Finish = Schema.Struct({
+  type: Schema.tag("finish"),
   reason: FinishReason,
   usage: Schema.optional(Usage),
   providerMetadata: Schema.optional(ProviderMetadata),
-}).annotate({ identifier: "LLM.Event.RequestFinish" })
-export type RequestFinish = Schema.Schema.Type<typeof RequestFinish>
+}).annotate({ identifier: "LLM.Event.Finish" })
+export type Finish = Schema.Schema.Type<typeof Finish>
 
 export const ProviderErrorEvent = Schema.Struct({
   type: Schema.tag("provider-error"),
@@ -202,7 +201,6 @@ export const ProviderErrorEvent = Schema.Struct({
 export type ProviderErrorEvent = Schema.Schema.Type<typeof ProviderErrorEvent>
 
 const llmEventTagged = Schema.Union([
-  RequestStart,
   StepStart,
   TextStart,
   TextDelta,
@@ -217,16 +215,15 @@ const llmEventTagged = Schema.Union([
   ToolResult,
   ToolError,
   StepFinish,
-  RequestFinish,
+  Finish,
   ProviderErrorEvent,
 ]).pipe(Schema.toTaggedUnion("type"))
 
 type WithID<Event extends { readonly id: unknown }, ID> = Omit<Event, "type" | "id"> & { readonly id: ID | string }
 type WithUsage<Event extends { readonly usage?: Usage }> = Omit<Event, "type" | "usage"> & {
-  readonly usage?: Usage | ConstructorParameters<typeof Usage>[0]
+  readonly usage?: UsageInput
 }
 
-const responseID = (value: ResponseID | string) => ResponseID.make(value)
 const contentBlockID = (value: ContentBlockID | string) => ContentBlockID.make(value)
 const toolCallID = (value: ToolCallID | string) => ToolCallID.make(value)
 
@@ -236,7 +233,6 @@ const toolCallID = (value: ToolCallID | string) => ToolCallID.make(value)
  * `events.filter(LLMEvent.guards["tool-call"])`.
  */
 export const LLMEvent = Object.assign(llmEventTagged, {
-  requestStart: (input: WithID<RequestStart, ResponseID>) => RequestStart.make({ ...input, id: responseID(input.id) }),
   stepStart: StepStart.make,
   textStart: (input: WithID<TextStart, ContentBlockID>) => TextStart.make({ ...input, id: contentBlockID(input.id) }),
   textDelta: (input: WithID<TextDelta, ContentBlockID>) => TextDelta.make({ ...input, id: contentBlockID(input.id) }),
@@ -258,16 +254,15 @@ export const LLMEvent = Object.assign(llmEventTagged, {
   stepFinish: (input: WithUsage<StepFinish>) =>
     StepFinish.make({
       ...input,
-      usage: input.usage === undefined ? undefined : input.usage instanceof Usage ? input.usage : new Usage(input.usage),
+      usage: input.usage === undefined ? undefined : Usage.from(input.usage),
     }),
-  requestFinish: (input: WithUsage<RequestFinish>) =>
-    RequestFinish.make({
+  finish: (input: WithUsage<Finish>) =>
+    Finish.make({
       ...input,
-      usage: input.usage === undefined ? undefined : input.usage instanceof Usage ? input.usage : new Usage(input.usage),
+      usage: input.usage === undefined ? undefined : Usage.from(input.usage),
     }),
   providerError: ProviderErrorEvent.make,
   is: {
-    requestStart: llmEventTagged.guards["request-start"],
     stepStart: llmEventTagged.guards["step-start"],
     textStart: llmEventTagged.guards["text-start"],
     textDelta: llmEventTagged.guards["text-delta"],
@@ -282,7 +277,7 @@ export const LLMEvent = Object.assign(llmEventTagged, {
     toolResult: llmEventTagged.guards["tool-result"],
     toolError: llmEventTagged.guards["tool-error"],
     stepFinish: llmEventTagged.guards["step-finish"],
-    requestFinish: llmEventTagged.guards["request-finish"],
+    finish: llmEventTagged.guards.finish,
     providerError: llmEventTagged.guards["provider-error"],
   },
 })

packages/llm/src/tool-runtime.ts

@@ -12,6 +12,7 @@ import {
   ToolFailure,
   ToolResultPart,
   type ToolResultValue,
+  Usage,
 } from "./schema"
 import { type AnyTool, type ExecutableTools, type Tools, toDefinitions } from "./tool"
 
@@ -72,19 +73,42 @@ export const stream = <T extends Tools>(options: StreamOptions<T>): Stream.Strea
           tools: [...options.request.tools.filter((tool) => !runtimeToolNames.has(tool.name)), ...runtimeTools],
         })
 
-  const loop = (request: LLMRequest, step: number): Stream.Stream<LLMEvent, LLMError> =>
+  const loop = (
+    request: LLMRequest,
+    step: number,
+    usage: Usage | undefined,
+    providerMetadata: ProviderMetadata | undefined,
+  ): Stream.Stream<LLMEvent, LLMError> =>
     Stream.unwrap(
       Effect.gen(function* () {
-        const state: StepState = { assistantContent: [], toolCalls: [], finishReason: undefined }
+        const state: StepState = {
+          assistantContent: [],
+          toolCalls: [],
+          finishReason: undefined,
+          usage: undefined,
+          providerMetadata: undefined,
+        }
 
         const modelStream = options
           .stream(request)
+          .pipe(Stream.map((event) => indexStep(event, step)))
           .pipe(Stream.tap((event) => Effect.sync(() => accumulate(state, event))))
+          .pipe(Stream.filter((event) => event.type !== "finish"))
 
         const continuation = Stream.unwrap(
           Effect.gen(function* () {
-            if (state.finishReason !== "tool-calls" || state.toolCalls.length === 0) return Stream.empty
-            if (options.toolExecution === "none") return Stream.empty
+            const totalUsage = addUsage(usage, state.usage)
+            const totalProviderMetadata = mergeProviderMetadata(providerMetadata, state.providerMetadata)
+            const finishStream = Stream.fromIterable([
+              LLMEvent.finish({
+                reason: state.finishReason ?? "unknown",
+                usage: totalUsage,
+                providerMetadata: totalProviderMetadata,
+              }),
+            ])
+
+            if (state.finishReason !== "tool-calls" || state.toolCalls.length === 0) return finishStream
+            if (options.toolExecution === "none") return finishStream
 
             const dispatched = yield* Effect.forEach(
               state.toolCalls,
@@ -93,10 +117,14 @@ export const stream = <T extends Tools>(options: StreamOptions<T>): Stream.Strea
             )
             const resultStream = Stream.fromIterable(dispatched.flatMap(([call, result]) => emitEvents(call, result)))
 
-            if (!options.stopWhen) return resultStream
-            if (options.stopWhen({ step, request })) return resultStream
+            if (!options.stopWhen) return resultStream.pipe(Stream.concat(finishStream))
+            if (options.stopWhen({ step, request })) return resultStream.pipe(Stream.concat(finishStream))
 
-            return resultStream.pipe(Stream.concat(loop(followUpRequest(request, state, dispatched), step + 1)))
+            return resultStream.pipe(
+              Stream.concat(
+                loop(followUpRequest(request, state, dispatched), step + 1, totalUsage, totalProviderMetadata),
+              ),
+            )
           }),
         )
 
@@ -104,13 +132,21 @@ export const stream = <T extends Tools>(options: StreamOptions<T>): Stream.Strea
       }),
     )
 
-  return loop(initialRequest, 0)
+  return loop(initialRequest, 0, undefined, undefined)
+}
+
+const indexStep = (event: LLMEvent, index: number): LLMEvent => {
+  if (event.type === "step-start") return LLMEvent.stepStart({ index })
+  if (event.type === "step-finish") return LLMEvent.stepFinish({ ...event, index })
+  return event
 }
 
 interface StepState {
   assistantContent: ContentPart[]
   toolCalls: ToolCallPart[]
   finishReason: FinishReason | undefined
+  usage: Usage | undefined
+  providerMetadata: ProviderMetadata | undefined
 }
 
 const accumulate = (state: StepState, event: LLMEvent) => {
@@ -154,9 +190,43 @@ const accumulate = (state: StepState, event: LLMEvent) => {
     )
     return
   }
-  if (event.type === "step-finish" || event.type === "request-finish") {
+  if (event.type === "step-finish") {
     state.finishReason = event.reason === "stop" && state.toolCalls.length > 0 ? "tool-calls" : event.reason
+    state.usage = addUsage(state.usage, event.usage)
+    state.providerMetadata = mergeProviderMetadata(state.providerMetadata, event.providerMetadata)
+    return
   }
+  if (event.type === "finish") {
+    state.finishReason ??= event.reason
+    state.usage ??= event.usage
+    state.providerMetadata = mergeProviderMetadata(state.providerMetadata, event.providerMetadata)
+  }
+}
+
+const addUsage = (left: Usage | undefined, right: Usage | undefined) => {
+  if (!left) return right
+  if (!right) return left
+  type UsageKey =
+    | "inputTokens"
+    | "outputTokens"
+    | "nonCachedInputTokens"
+    | "cacheReadInputTokens"
+    | "cacheWriteInputTokens"
+    | "reasoningTokens"
+    | "totalTokens"
+  const sum = (key: UsageKey) =>
+    left[key] === undefined && right[key] === undefined ? undefined : Number(left[key] ?? 0) + Number(right[key] ?? 0)
+
+  return new Usage({
+    inputTokens: sum("inputTokens"),
+    outputTokens: sum("outputTokens"),
+    nonCachedInputTokens: sum("nonCachedInputTokens"),
+    cacheReadInputTokens: sum("cacheReadInputTokens"),
+    cacheWriteInputTokens: sum("cacheWriteInputTokens"),
+    reasoningTokens: sum("reasoningTokens"),
+    totalTokens: sum("totalTokens"),
+    providerMetadata: mergeProviderMetadata(left.providerMetadata, right.providerMetadata),
+  })
 }
 
 const sameProviderMetadata = (left: ProviderMetadata | undefined, right: ProviderMetadata | undefined) =>

packages/llm/src/tool.ts

@@ -1,5 +1,5 @@
 import { Effect, JsonSchema, Schema } from "effect"
-import type { ToolDefinition as ToolDefinitionClass } from "./schema"
+import type { ToolCallPart, ToolDefinition as ToolDefinitionClass } from "./schema"
 import { ToolDefinition, ToolFailure } from "./schema"
 
 /**
@@ -8,10 +8,14 @@ import { ToolDefinition, ToolFailure } from "./schema"
  * beyond pure data conversion belongs in the handler closure.
  */
 export type ToolSchema<T> = Schema.Codec<T, any, never, never>
+export interface ToolExecuteContext {
+  readonly id: ToolCallPart["id"]
+  readonly name: ToolCallPart["name"]
+}
 
 export type ToolExecute<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> = (
   params: Schema.Schema.Type<Parameters>,
-  context?: { readonly id: string; readonly name: string },
+  context?: ToolExecuteContext,
 ) => Effect.Effect<Schema.Schema.Type<Success>, ToolFailure>
 
 /**
@@ -62,10 +66,7 @@ type TypedToolConfig = {
 type DynamicToolConfig = {
   readonly description: string
   readonly jsonSchema: JsonSchema.JsonSchema
-  readonly execute?: (
-    params: unknown,
-    context?: { readonly id: string; readonly name: string },
-  ) => Effect.Effect<unknown, ToolFailure>
+  readonly execute?: (params: unknown, context?: ToolExecuteContext) => Effect.Effect<unknown, ToolFailure>
 }
 
 /**
@@ -114,10 +115,7 @@ export function make<Parameters extends ToolSchema<any>, Success extends ToolSch
 export function make(config: {
   readonly description: string
   readonly jsonSchema: JsonSchema.JsonSchema
-  readonly execute: (
-    params: unknown,
-    context?: { readonly id: string; readonly name: string },
-  ) => Effect.Effect<unknown, ToolFailure>
+  readonly execute: (params: unknown, context?: ToolExecuteContext) => Effect.Effect<unknown, ToolFailure>
 }): AnyExecutableTool
 export function make(config: {
   readonly description: string

packages/llm/test/adapter.test.ts

@@ -51,7 +51,7 @@ const request = LLM.request({
 
 const raiseEvent = (event: FakeEvent): import("../src/schema").LLMEvent =>
   event.type === "finish"
-    ? { type: "request-finish", reason: event.reason }
+    ? { type: "finish", reason: event.reason }
     : { type: "text-delta", id: "text-0", text: event.text }
 
 const fakeProtocol = Protocol.make<FakeBody, FakeEvent, FakeEvent, void>({
@@ -112,8 +112,8 @@ describe("llm route", () => {
       const events = Array.from(yield* llm.stream(request).pipe(Stream.runCollect))
       const response = yield* llm.generate(request)
 
-      expect(events.map((event) => event.type)).toEqual(["text-delta", "request-finish"])
-      expect(response.events.map((event) => event.type)).toEqual(["text-delta", "request-finish"])
+      expect(events.map((event) => event.type)).toEqual(["text-delta", "finish"])
+      expect(response.events.map((event) => event.type)).toEqual(["text-delta", "finish"])
     }),
   )
 

packages/llm/test/llm.test.ts

@@ -127,7 +127,7 @@ describe("llm constructors", () => {
       LLMResponse.text({
         events: [
           { type: "text-delta", id: "text-0", text: "hi" },
-          { type: "request-finish", reason: "stop" },
+          { type: "finish", reason: "stop" },
         ],
       }),
     ).toBe("hi")

packages/llm/test/provider/anthropic-messages.test.ts

@@ -124,7 +124,7 @@ describe("Anthropic Messages route", () => {
         providerMetadata: { anthropic: { signature: "sig_1" } },
       })
       expect(response.events.at(-1)).toMatchObject({
-        type: "request-finish",
+        type: "finish",
         reason: "stop",
         providerMetadata: { anthropic: { stopSequence: "\n\nHuman:" } },
       })
@@ -182,7 +182,7 @@ describe("Anthropic Messages route", () => {
         },
         { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
         {
-          type: "request-finish",
+          type: "finish",
           reason: "tool-calls",
           providerMetadata: undefined,
           usage,
@@ -275,7 +275,7 @@ describe("Anthropic Messages route", () => {
         providerMetadata: { anthropic: { blockType: "web_search_tool_result" } },
       })
       expect(response.text).toBe("Found it.")
-      expect(response.events.at(-1)).toMatchObject({ type: "request-finish", reason: "stop" })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "stop" })
     }),
   )
 

packages/llm/test/provider/bedrock-converse.test.ts

@@ -169,12 +169,12 @@ describe("Bedrock Converse route", () => {
       const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
 
       expect(response.text).toBe("Hello!")
-      const finishes = response.events.filter((event) => event.type === "request-finish")
+      const finishes = response.events.filter((event) => event.type === "finish")
       // Bedrock splits the finish across `messageStop` (carries reason) and
       // `metadata` (carries usage). We consolidate them into a single
-      // terminal `request-finish` event with both.
+      // terminal `finish` event with both.
       expect(finishes).toHaveLength(1)
-      expect(finishes[0]).toMatchObject({ type: "request-finish", reason: "stop" })
+      expect(finishes[0]).toMatchObject({ type: "finish", reason: "stop" })
       expect(response.usage).toMatchObject({
         inputTokens: 5,
         outputTokens: 2,
@@ -213,7 +213,7 @@ describe("Bedrock Converse route", () => {
         { type: "tool-input-delta", id: "tool_1", name: "lookup", text: '{"query"' },
         { type: "tool-input-delta", id: "tool_1", name: "lookup", text: ':"weather"}' },
       ])
-      expect(response.events.at(-1)).toMatchObject({ type: "request-finish", reason: "tool-calls" })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "tool-calls" })
     }),
   )
 

packages/llm/test/provider/gemini.test.ts

@@ -232,7 +232,7 @@ describe("Gemini route", () => {
         { type: "text-end", id: "text-0" },
         { type: "step-finish", index: 0, reason: "stop", usage, providerMetadata: undefined },
         {
-          type: "request-finish",
+          type: "finish",
           reason: "stop",
           usage,
         },
@@ -291,7 +291,7 @@ describe("Gemini route", () => {
         },
         { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
         {
-          type: "request-finish",
+          type: "finish",
           reason: "tool-calls",
           usage,
         },
@@ -325,7 +325,7 @@ describe("Gemini route", () => {
         { type: "tool-call", id: "tool_0", name: "lookup", input: { query: "weather" } },
         { type: "tool-call", id: "tool_1", name: "lookup", input: { query: "news" } },
       ])
-      expect(response.events.at(-1)).toMatchObject({ type: "request-finish", reason: "tool-calls" })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "tool-calls" })
     }),
   )
 
@@ -344,10 +344,10 @@ describe("Gemini route", () => {
         ),
       )
 
-      expect(length.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "request-finish"])
-      expect(length.events.at(-1)).toMatchObject({ type: "request-finish", reason: "length" })
-      expect(filtered.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "request-finish"])
-      expect(filtered.events.at(-1)).toMatchObject({ type: "request-finish", reason: "content-filter" })
+      expect(length.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "finish"])
+      expect(length.events.at(-1)).toMatchObject({ type: "finish", reason: "length" })
+      expect(filtered.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "finish"])
+      expect(filtered.events.at(-1)).toMatchObject({ type: "finish", reason: "content-filter" })
     }),
   )
 

packages/llm/test/provider/openai-chat.test.ts

@@ -249,7 +249,7 @@ describe("OpenAI Chat route", () => {
         { type: "text-end", id: "text-0" },
         { type: "step-finish", index: 0, reason: "stop", usage, providerMetadata: undefined },
         {
-          type: "request-finish",
+          type: "finish",
           reason: "stop",
           usage,
         },
@@ -288,7 +288,7 @@ describe("OpenAI Chat route", () => {
           providerMetadata: undefined,
         },
         { type: "step-finish", index: 0, reason: "tool-calls", usage: undefined, providerMetadata: undefined },
-        { type: "request-finish", reason: "tool-calls", usage: undefined },
+        { type: "finish", reason: "tool-calls", usage: undefined },
       ])
     }),
   )

packages/llm/test/provider/openai-compatible-chat.test.ts

@@ -231,7 +231,7 @@ describe("OpenAI-compatible Chat route", () => {
 
       expect(response.text).toBe("Hello!")
       expect(response.usage).toMatchObject({ inputTokens: 5, outputTokens: 2, totalTokens: 7 })
-      expect(response.events.at(-1)).toMatchObject({ type: "request-finish", reason: "stop" })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "stop" })
     }),
   )
 })

packages/llm/test/provider/openai-responses.test.ts

@@ -366,7 +366,7 @@ describe("OpenAI Responses route", () => {
           usage,
         },
         {
-          type: "request-finish",
+          type: "finish",
           reason: "stop",
           providerMetadata: { openai: { responseId: "resp_1", serviceTier: "default" } },
           usage,
@@ -447,7 +447,7 @@ describe("OpenAI Responses route", () => {
         },
         { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
         {
-          type: "request-finish",
+          type: "finish",
           reason: "tool-calls",
           providerMetadata: undefined,
           usage,

packages/llm/test/recorded-scenarios.ts

@@ -120,8 +120,8 @@ export const runWeatherToolLoop = (request: LLMRequest) =>
 
 export const expectFinish = (
   events: ReadonlyArray<LLMEvent>,
-  reason: Extract<LLMEvent, { readonly type: "request-finish" }>["reason"],
-) => expect(events.at(-1)).toMatchObject({ type: "request-finish", reason })
+  reason: Extract<LLMEvent, { readonly type: "finish" }>["reason"],
+) => expect(events.at(-1)).toMatchObject({ type: "finish", reason })
 
 export const expectWeatherToolCall = (response: LLMResponse) =>
   expect(response.toolCalls).toMatchObject([
@@ -129,10 +129,12 @@ export const expectWeatherToolCall = (response: LLMResponse) =>
   ])
 
 export const expectWeatherToolLoop = (events: ReadonlyArray<LLMEvent>) => {
-  const finishes = events.filter(LLMEvent.is.requestFinish)
-  expect(finishes).toHaveLength(2)
-  expect(finishes[0]?.reason).toBe("tool-calls")
-  expect(finishes.at(-1)?.reason).toBe("stop")
+  const finishes = events.filter(LLMEvent.is.finish)
+  expect(finishes).toHaveLength(1)
+  expect(finishes[0]?.reason).toBe("stop")
+
+  const stepFinishes = events.filter(LLMEvent.is.stepFinish)
+  expect(stepFinishes.map((event) => event.reason)).toEqual(["tool-calls", "stop"])
 
   const toolCalls = events.filter(LLMEvent.is.toolCall)
   expect(toolCalls).toHaveLength(1)
@@ -272,7 +274,7 @@ export const eventSummary = (events: ReadonlyArray<LLMEvent>) => {
       summary.push({ type: "tool-error", name: event.name, message: event.message })
       continue
     }
-    if (event.type === "request-finish") {
+    if (event.type === "finish") {
       summary.push({ type: "finish", reason: event.reason, usage: usageSummary(event.usage) })
     }
   }

packages/llm/test/schema.test.ts

@@ -44,6 +44,11 @@ describe("llm schema", () => {
     expect(() => Schema.decodeUnknownSync(LLMEvent)({ type: "bogus" })).toThrow()
   })
 
+  test("finish constructors accept usage input", () => {
+    expect(LLMEvent.stepFinish({ index: 0, reason: "stop", usage: { inputTokens: 1 } }).usage).toBeInstanceOf(Usage)
+    expect(LLMEvent.finish({ reason: "stop", usage: { outputTokens: 2 } }).usage).toBeInstanceOf(Usage)
+  })
+
   test("content part tagged union exposes guards", () => {
     expect(ContentPart.guards.text({ type: "text", text: "hi" })).toBe(true)
     expect(ContentPart.guards.media({ type: "text", text: "hi" })).toBe(false)

packages/llm/test/tool-runtime.test.ts

@@ -4,7 +4,8 @@ import { GenerationOptions, LLM, LLMEvent, LLMRequest, LLMResponse, ToolChoice }
 import { LLMClient } from "../src/route"
 import * as AnthropicMessages from "../src/protocols/anthropic-messages"
 import * as OpenAIChat from "../src/protocols/openai-chat"
-import { tool, ToolFailure } from "../src/tool"
+import { tool, ToolFailure, type ToolExecuteContext } from "../src/tool"
+import { ToolRuntime } from "../src/tool-runtime"
 import { it } from "./lib/effect"
 import * as TestToolRuntime from "./lib/tool-runtime"
 import { dynamicResponse, scriptedResponses } from "./lib/http"
@@ -129,7 +130,7 @@ describe("LLMClient tools", () => {
         name: "get_weather",
         result: { type: "json", value: { temperature: 22, condition: "sunny" } },
       })
-      expect(events.at(-1)?.type).toBe("request-finish")
+      expect(events.at(-1)?.type).toBe("finish")
       expect(LLMResponse.text({ events })).toBe("It's sunny in Paris.")
     }),
   )
@@ -148,11 +149,40 @@ describe("LLMClient tools", () => {
         ),
       )
 
-      expect(events.filter(LLMEvent.is.requestFinish)).toHaveLength(1)
+      expect(events.filter(LLMEvent.is.finish)).toHaveLength(1)
       expect(events.find(LLMEvent.is.toolResult)).toMatchObject({ type: "tool-result", id: "call_1" })
     }),
   )
 
+  it.effect("passes tool call context to execute", () =>
+    Effect.gen(function* () {
+      let context: ToolExecuteContext | undefined
+      const contextual = tool({
+        description: "Capture tool context.",
+        parameters: Schema.Struct({ value: Schema.String }),
+        success: Schema.Struct({ ok: Schema.Boolean }),
+        execute: (_params, ctx) =>
+          Effect.sync(() => {
+            context = ctx
+            return { ok: true }
+          }),
+      })
+      const events = Array.from(
+        yield* TestToolRuntime.runTools({ request: baseRequest, tools: { contextual } }).pipe(
+          Stream.runCollect,
+          Effect.provide(
+            scriptedResponses([
+              sseEvents(toolCallChunk("call_ctx", "contextual", '{"value":"x"}'), finishChunk("tool_calls")),
+            ]),
+          ),
+        ),
+      )
+
+      expect(events.some(LLMEvent.is.toolResult)).toBe(true)
+      expect(context).toEqual({ id: "call_ctx", name: "contextual" })
+    }),
+  )
+
   it.effect("can expose tool schemas without executing tool calls", () =>
     Effect.gen(function* () {
       const layer = scriptedResponses([
@@ -319,7 +349,7 @@ describe("LLMClient tools", () => {
         "text-delta",
         "text-end",
         "step-finish",
-        "request-finish",
+        "finish",
       ])
       expect(LLMResponse.text({ events })).toBe("Done.")
     }),
@@ -343,7 +373,57 @@ describe("LLMClient tools", () => {
         ),
       )
 
-      expect(events.filter(LLMEvent.is.requestFinish)).toHaveLength(2)
+      expect(events.filter(LLMEvent.is.finish)).toHaveLength(1)
+      expect(events.filter(LLMEvent.is.stepStart).map((event) => event.index)).toEqual([0, 1])
+      expect(events.filter(LLMEvent.is.stepFinish).map((event) => event.index)).toEqual([0, 1])
+    }),
+  )
+
+  it.effect("emits one final finish with aggregate usage", () =>
+    Effect.gen(function* () {
+      let calls = 0
+      const events = Array.from(
+        yield* ToolRuntime.stream({
+          request: baseRequest,
+          tools: { get_weather },
+          stopWhen: ToolRuntime.stepCountIs(2),
+          stream: () =>
+            Stream.fromIterable<LLMEvent>(
+              calls++ === 0
+                ? [
+                    LLMEvent.stepStart({ index: 0 }),
+                    LLMEvent.toolCall({ id: "call_1", name: "get_weather", input: { city: "Paris" } }),
+                    LLMEvent.stepFinish({
+                      index: 0,
+                      reason: "tool-calls",
+                      usage: { inputTokens: 1, outputTokens: 2, totalTokens: 3 },
+                    }),
+                    LLMEvent.finish({
+                      reason: "tool-calls",
+                      usage: { inputTokens: 1, outputTokens: 2, totalTokens: 3 },
+                    }),
+                  ]
+                : [
+                    LLMEvent.stepStart({ index: 0 }),
+                    LLMEvent.textDelta({ id: "text_1", text: "Done." }),
+                    LLMEvent.stepFinish({
+                      index: 0,
+                      reason: "stop",
+                      usage: { inputTokens: 4, outputTokens: 5, totalTokens: 9 },
+                    }),
+                    LLMEvent.finish({ reason: "stop", usage: { inputTokens: 4, outputTokens: 5, totalTokens: 9 } }),
+                  ],
+            ),
+        }).pipe(Stream.runCollect),
+      )
+
+      expect(events.filter(LLMEvent.is.stepFinish).map((event) => event.index)).toEqual([0, 1])
+      expect(events.filter(LLMEvent.is.finish)).toHaveLength(1)
+      expect(events.find(LLMEvent.is.finish)?.usage).toMatchObject({
+        inputTokens: 5,
+        outputTokens: 7,
+        totalTokens: 12,
+      })
     }),
   )
 
@@ -362,7 +442,7 @@ describe("LLMClient tools", () => {
         }).pipe(Stream.runCollect, Effect.provide(layer)),
       )
 
-      expect(events.filter(LLMEvent.is.requestFinish)).toHaveLength(1)
+      expect(events.filter(LLMEvent.is.finish)).toHaveLength(1)
       expect(events.find(LLMEvent.is.toolResult)).toMatchObject({ type: "tool-result", id: "call_1" })
     }),
   )

packages/opencode/package.json

@@ -105,7 +105,6 @@
     "@octokit/graphql": "9.0.2",
     "@octokit/rest": "catalog:",
     "@openauthjs/openauth": "catalog:",
-    "@opencode-ai/llm": "workspace:*",
     "@opencode-ai/plugin": "workspace:*",
     "@opencode-ai/script": "workspace:*",
     "@opencode-ai/sdk": "workspace:*",

packages/opencode/src/acp/agent.ts

@@ -1094,8 +1094,8 @@ export class Agent implements ACPAgent {
 
     const currentModeId = await (async () => {
       if (!availableModes.length) return undefined
-      const defaultAgentName = await AppRuntime.runPromise(AgentModule.Service.use((svc) => svc.defaultAgent()))
-      const resolvedModeId = availableModes.find((mode) => mode.name === defaultAgentName)?.id ?? availableModes[0].id
+      const defaultAgent = await AppRuntime.runPromise(AgentModule.Service.use((svc) => svc.defaultInfo()))
+      const resolvedModeId = availableModes.find((mode) => mode.name === defaultAgent.name)?.id ?? availableModes[0].id
       this.sessionManager.setMode(sessionId, resolvedModeId)
       return resolvedModeId
     })()
@@ -1328,7 +1328,8 @@ export class Agent implements ACPAgent {
     if (!current) {
       this.sessionManager.setModel(session.id, model)
     }
-    const agent = session.modeId ?? (await AppRuntime.runPromise(AgentModule.Service.use((svc) => svc.defaultAgent())))
+    const agent =
+      session.modeId ?? (await AppRuntime.runPromise(AgentModule.Service.use((svc) => svc.defaultInfo()))).name
 
     const parts: Array<
       | { type: "text"; text: string; synthetic?: boolean; ignored?: boolean }

packages/opencode/src/agent/agent.ts

@@ -57,6 +57,7 @@ const GeneratedAgent = Schema.Struct({
 export interface Interface {
   readonly get: (agent: string) => Effect.Effect<Info>
   readonly list: () => Effect.Effect<Info[]>
+  readonly defaultInfo: () => Effect.Effect<Info>
   readonly defaultAgent: () => Effect.Effect<string>
   readonly generate: (input: {
     description: string
@@ -333,23 +334,28 @@ export const layer = Layer.effect(
           )
         })
 
-        const defaultAgent = Effect.fnUntraced(function* () {
+        const defaultInfo = Effect.fnUntraced(function* () {
           const c = yield* config.get()
           if (c.default_agent) {
             const agent = agents[c.default_agent]
             if (!agent) throw new Error(`default agent "${c.default_agent}" not found`)
             if (agent.mode === "subagent") throw new Error(`default agent "${c.default_agent}" is a subagent`)
             if (agent.hidden === true) throw new Error(`default agent "${c.default_agent}" is hidden`)
-            return agent.name
+            return agent
           }
           const visible = Object.values(agents).find((a) => a.mode !== "subagent" && a.hidden !== true)
           if (!visible) throw new Error("no primary visible agent found")
-          return visible.name
+          return visible
+        })
+
+        const defaultAgent = Effect.fnUntraced(function* () {
+          return (yield* defaultInfo()).name
         })
 
         return {
           get,
           list,
+          defaultInfo,
           defaultAgent,
         } satisfies State
       }),
@@ -362,6 +368,9 @@ export const layer = Layer.effect(
       list: Effect.fn("Agent.list")(function* () {
         return yield* InstanceState.useEffect(state, (s) => s.list())
       }),
+      defaultInfo: Effect.fn("Agent.defaultInfo")(function* () {
+        return yield* InstanceState.useEffect(state, (s) => s.defaultInfo())
+      }),
       defaultAgent: Effect.fn("Agent.defaultAgent")(function* () {
         return yield* InstanceState.useEffect(state, (s) => s.defaultAgent())
       }),

packages/opencode/src/cli/error.ts

@@ -78,8 +78,8 @@ export function FormatError(input: unknown) {
     ].join("\n")
   }
 
-  // UICancelledError: void (no data)
-  if (NamedError.hasName(input, "UICancelledError")) {
+  // UICancelledError: user cancelled an interactive CLI prompt
+  if (isTaggedError(input, "UICancelledError") || NamedError.hasName(input, "UICancelledError")) {
     return ""
   }
 }

packages/opencode/src/cli/ui.ts

@@ -1,5 +1,4 @@
 import { EOL } from "os"
-import { NamedError } from "@opencode-ai/core/util/error"
 import { Schema } from "effect"
 import { logo as glyphs } from "./logo"
 
@@ -10,7 +9,7 @@ const wordmark = [
   `▀▀▀▀ █▀▀▀ ▀▀▀▀ ▀  ▀ ▀▀▀▀ ▀▀▀▀ ▀▀▀▀ ▀▀▀▀`,
 ]
 
-export const CancelledError = NamedError.create("UICancelledError", Schema.optional(Schema.Void))
+export class CancelledError extends Schema.TaggedErrorClass<CancelledError>()("UICancelledError", {}) {}
 
 export const Style = {
   TEXT_HIGHLIGHT: "\x1b[96m",

packages/opencode/src/data-migration.ts

@@ -94,6 +94,7 @@ export const layer = Layer.effect(
                         tokens_reasoning: value.tokens.reasoning,
                         tokens_cache_read: value.tokens.cache.read,
                         tokens_cache_write: value.tokens.cache.write,
+                        time_updated: sql`${SessionTable.time_updated}`,
                       })
                       .where(eq(SessionTable.id, sessionID))
                       .run()
@@ -145,7 +146,9 @@ export const layer = Layer.effect(
         )
       }
     }).pipe(
-      Effect.tapCause((cause) => Effect.logError("failed to run data migrations", { cause })),
+      Effect.tapCause((cause) =>
+        Effect.logError("failed to run data migrations").pipe(Effect.annotateLogs("cause", cause)),
+      ),
       Effect.ignore,
       Effect.forkScoped,
     )

packages/opencode/src/effect/runner.ts

@@ -181,7 +181,7 @@ export const make = <A, E = never>(
         return [
           Effect.gen(function* () {
             yield* Fiber.interrupt(st.run.fiber)
-            yield* Deferred.await(st.run.done).pipe(Effect.exit, Effect.asVoid)
+            yield* Deferred.fail(st.run.done, new Cancelled()).pipe(Effect.asVoid)
             yield* idleIfCurrent()
           }),
           { _tag: "Idle" } as const,

packages/opencode/src/mcp/index.ts

@@ -6,6 +6,7 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js"
 import {
   CallToolResultSchema,
+  ListToolsResultSchema,
   ToolSchema,
   type Tool as MCPToolDef,
   ToolListChangedNotificationSchema,
@@ -14,7 +15,6 @@ import { Config } from "@/config/config"
 import { ConfigMCP } from "../config/mcp"
 import * as Log from "@opencode-ai/core/util/log"
 import { NamedError } from "@opencode-ai/core/util/error"
-import z from "zod/v4"
 import { Installation } from "../installation"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { withTimeout } from "@/util/timeout"
@@ -35,13 +35,8 @@ import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 const log = Log.create({ service: "mcp" })
 const DEFAULT_TIMEOUT = 30_000
 
-const TolerantToolSchema = ToolSchema.extend({
-  outputSchema: z.unknown().optional(),
-})
-
-const TolerantListToolsResultSchema = z.looseObject({
-  tools: z.array(TolerantToolSchema),
-  nextCursor: z.string().optional(),
+const TolerantListToolsResultSchema = ListToolsResultSchema.extend({
+  tools: ToolSchema.omit({ outputSchema: true }).array(),
 })
 
 export const Resource = Schema.Struct({
@@ -137,7 +132,10 @@ function listTools(key: string, client: MCPClient, timeout: number) {
 
       log.warn("failed to validate MCP tool output schemas, retrying without output schema validation", { key, error })
       return Effect.tryPromise({
-        try: () => client.request({ method: "tools/list" }, TolerantListToolsResultSchema, { timeout }),
+        try: () =>
+          client.request({ method: "tools/list" }, TolerantListToolsResultSchema, {
+            timeout,
+          }),
         catch: (err) => (err instanceof Error ? err : new Error(String(err))),
       }).pipe(
         Effect.map((result) =>

packages/opencode/src/project/bootstrap.ts

@@ -37,7 +37,7 @@ export const layer = Layer.effect(
 
     const run = Effect.gen(function* () {
       const ctx = yield* InstanceState.context
-      yield* Effect.logInfo("bootstrapping", { directory: ctx.directory })
+      yield* Effect.logInfo("bootstrapping").pipe(Effect.annotateLogs("directory", ctx.directory))
       // everything depends on config so eager load it for nice traces
       yield* config.get()
       // Plugin can mutate config so it has to be initialized before anything else.

packages/opencode/src/project/instance-store.ts

@@ -156,7 +156,9 @@ export const layer: Layer.Layer<Service, never, Project.Service | InstanceBootst
           Effect.gen(function* () {
             const exit = yield* Deferred.await(item[1].deferred).pipe(Effect.exit)
             if (Exit.isFailure(exit)) {
-              yield* Effect.logWarning("instance dispose failed", { key: item[0], cause: exit.cause })
+              yield* Effect.logWarning("instance dispose failed").pipe(
+                Effect.annotateLogs({ key: item[0], cause: exit.cause }),
+              )
               yield* removeEntry(item[0], item[1])
               return
             }

packages/opencode/src/provider/auth.ts

@@ -1,7 +1,7 @@
 import type { AuthOAuthResult, Hooks } from "@opencode-ai/plugin"
 import { Auth } from "@/auth"
 import { InstanceState } from "@/effect/instance-state"
-import { namedSchemaError } from "@/util/named-schema-error"
+import { NamedError } from "@opencode-ai/core/util/error"
 import { optionalOmitUndefined } from "@opencode-ai/core/schema"
 import { Plugin } from "../plugin"
 import { ProviderID } from "./schema"
@@ -64,13 +64,13 @@ export const CallbackInput = Schema.Struct({
 })
 export type CallbackInput = Schema.Schema.Type<typeof CallbackInput>
 
-export const OauthMissing = namedSchemaError("ProviderAuthOauthMissing", { providerID: ProviderID })
+export const OauthMissing = NamedError.create("ProviderAuthOauthMissing", { providerID: ProviderID })
 
-export const OauthCodeMissing = namedSchemaError("ProviderAuthOauthCodeMissing", { providerID: ProviderID })
+export const OauthCodeMissing = NamedError.create("ProviderAuthOauthCodeMissing", { providerID: ProviderID })
 
-export const OauthCallbackFailed = namedSchemaError("ProviderAuthOauthCallbackFailed", {})
+export const OauthCallbackFailed = NamedError.create("ProviderAuthOauthCallbackFailed", {})
 
-export const ValidationFailed = namedSchemaError("ProviderAuthValidationFailed", {
+export const ValidationFailed = NamedError.create("ProviderAuthValidationFailed", {
   field: Schema.String,
   message: Schema.String,
 })

packages/opencode/src/provider/models.ts

@@ -177,7 +177,9 @@ export const layer: Layer.Layer<Service, never, AppFileSystem.Service | HttpClie
           yield* invalidate
         }),
       ).pipe(
-        Effect.tapCause((cause) => Effect.logError("Failed to fetch models.dev", { cause })),
+        Effect.tapCause((cause) =>
+          Effect.logError("Failed to fetch models.dev").pipe(Effect.annotateLogs("cause", cause)),
+        ),
         Effect.ignore,
       )
     })

packages/opencode/src/provider/provider.ts

@@ -13,7 +13,7 @@ import { Auth } from "../auth"
 import { Env } from "../env"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { Flag } from "@opencode-ai/core/flag/flag"
-import { namedSchemaError } from "@/util/named-schema-error"
+import { NamedError } from "@opencode-ai/core/util/error"
 import { iife } from "@/util/iife"
 import { Global } from "@opencode-ai/core/global"
 import path from "path"
@@ -1749,13 +1749,13 @@ export function parseModel(model: string) {
   }
 }
 
-export const ModelNotFoundError = namedSchemaError("ProviderModelNotFoundError", {
+export const ModelNotFoundError = NamedError.create("ProviderModelNotFoundError", {
   providerID: ProviderID,
   modelID: ModelID,
   suggestions: Schema.optional(Schema.Array(Schema.String)),
 })
 
-export const InitError = namedSchemaError("ProviderInitError", {
+export const InitError = NamedError.create("ProviderInitError", {
   providerID: ProviderID,
 })
 

packages/opencode/src/reference/reference.ts

@@ -169,7 +169,9 @@ export const layer = Layer.effect(
               ).pipe(
                 Effect.asVoid,
                 Effect.catchCause((cause) =>
-                  Effect.logWarning("failed to materialize reference repository", { name: reference.name, cause }),
+                  Effect.logWarning("failed to materialize reference repository").pipe(
+                    Effect.annotateLogs({ name: reference.name, cause }),
+                  ),
                 ),
               ),
             )

packages/opencode/src/server/routes/instance/httpapi/handlers/experimental.ts

@@ -79,7 +79,7 @@ export const experimentalHandlers = HttpApiBuilder.group(InstanceHttpApi, "exper
       const list = yield* registry.tools({
         providerID: ctx.query.provider,
         modelID: ctx.query.model,
-        agent: yield* agents.get(yield* agents.defaultAgent()),
+        agent: yield* agents.defaultInfo(),
       })
       return list.map((item) => ({
         id: item.id,

packages/opencode/src/server/routes/instance/httpapi/handlers/session.ts

@@ -299,7 +299,9 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
       yield* promptSvc.prompt({ ...ctx.payload, sessionID: ctx.params.sessionID }).pipe(
         Effect.catchCause((cause) =>
           Effect.gen(function* () {
-            yield* Effect.logError("prompt_async failed", { sessionID: ctx.params.sessionID, cause })
+            yield* Effect.logError("prompt_async failed").pipe(
+              Effect.annotateLogs({ sessionID: ctx.params.sessionID, cause }),
+            )
             yield* bus.publish(Session.Event.Error, {
               sessionID: ctx.params.sessionID,
               error: new NamedError.Unknown({ message: Cause.pretty(cause) }).toObject(),

packages/opencode/src/session/llm-ai-sdk.ts

@@ -1,230 +0,0 @@
-import { FinishReason, LLMEvent, ProviderMetadata, ToolResultValue } from "@opencode-ai/llm"
-import { Effect, Schema } from "effect"
-import { type streamText } from "ai"
-import { errorMessage } from "@/util/error"
-
-type Result = Awaited<ReturnType<typeof streamText>>
-type AISDKEvent = Result["fullStream"] extends AsyncIterable<infer T> ? T : never
-
-export function adapterState() {
-  return {
-    step: 0,
-    text: 0,
-    reasoning: 0,
-    currentTextID: undefined as string | undefined,
-    currentReasoningID: undefined as string | undefined,
-    toolNames: {} as Record<string, string>,
-  }
-}
-
-function finishReason(value: string | undefined): FinishReason {
-  return Schema.is(FinishReason)(value) ? value : "unknown"
-}
-
-function providerMetadata(value: unknown): ProviderMetadata | undefined {
-  return Schema.is(ProviderMetadata)(value) ? value : undefined
-}
-
-function usage(value: unknown) {
-  if (!value || typeof value !== "object") return undefined
-  const item = value as {
-    inputTokens?: number
-    outputTokens?: number
-    totalTokens?: number
-    reasoningTokens?: number
-    cachedInputTokens?: number
-    inputTokenDetails?: { cacheReadTokens?: number; cacheWriteTokens?: number }
-    outputTokenDetails?: { reasoningTokens?: number }
-  }
-  const result = Object.fromEntries(
-    Object.entries({
-      inputTokens: item.inputTokens,
-      outputTokens: item.outputTokens,
-      totalTokens: item.totalTokens,
-      reasoningTokens: item.outputTokenDetails?.reasoningTokens ?? item.reasoningTokens,
-      cacheReadInputTokens: item.inputTokenDetails?.cacheReadTokens ?? item.cachedInputTokens,
-      cacheWriteInputTokens: item.inputTokenDetails?.cacheWriteTokens,
-    }).filter((entry) => entry[1] !== undefined),
-  )
-  return result
-}
-
-function currentTextID(state: ReturnType<typeof adapterState>, id: string | undefined) {
-  state.currentTextID = id ?? state.currentTextID ?? `text-${state.text++}`
-  return state.currentTextID
-}
-
-function currentReasoningID(state: ReturnType<typeof adapterState>, id: string | undefined) {
-  state.currentReasoningID = id ?? state.currentReasoningID ?? `reasoning-${state.reasoning++}`
-  return state.currentReasoningID
-}
-
-export function toLLMEvents(
-  state: ReturnType<typeof adapterState>,
-  event: AISDKEvent,
-): Effect.Effect<ReadonlyArray<LLMEvent>, unknown> {
-  switch (event.type) {
-    case "start":
-      return Effect.succeed([])
-
-    case "start-step":
-      return Effect.succeed([LLMEvent.stepStart({ index: state.step })])
-
-    case "finish-step":
-      return Effect.sync(() => [
-        LLMEvent.stepFinish({
-          index: state.step++,
-          reason: finishReason(event.finishReason),
-          usage: usage(event.usage),
-          providerMetadata: providerMetadata(event.providerMetadata),
-        }),
-      ])
-
-    case "finish":
-      return Effect.sync(() => {
-        state.toolNames = {}
-        return [
-          LLMEvent.requestFinish({
-            reason: finishReason(event.finishReason),
-            usage: usage(event.totalUsage),
-          }),
-        ]
-      })
-
-    case "text-start":
-      return Effect.sync(() => {
-        state.currentTextID = currentTextID(state, event.id)
-        return [
-          LLMEvent.textStart({
-            id: state.currentTextID,
-            providerMetadata: providerMetadata(event.providerMetadata),
-          }),
-        ]
-      })
-
-    case "text-delta":
-      return Effect.succeed([
-        LLMEvent.textDelta({
-          id: currentTextID(state, event.id),
-          text: event.text,
-        }),
-      ])
-
-    case "text-end":
-      return Effect.succeed([
-        LLMEvent.textEnd({
-          id: currentTextID(state, event.id),
-          providerMetadata: providerMetadata(event.providerMetadata),
-        }),
-      ])
-
-    case "reasoning-start":
-      return Effect.sync(() => {
-        state.currentReasoningID = currentReasoningID(state, event.id)
-        return [
-          LLMEvent.reasoningStart({
-            id: state.currentReasoningID,
-            providerMetadata: providerMetadata(event.providerMetadata),
-          }),
-        ]
-      })
-
-    case "reasoning-delta":
-      return Effect.succeed([
-        LLMEvent.reasoningDelta({
-          id: currentReasoningID(state, event.id),
-          text: event.text,
-        }),
-      ])
-
-    case "reasoning-end":
-      return Effect.sync(() => {
-        const id = currentReasoningID(state, event.id)
-        state.currentReasoningID = undefined
-        return [
-          LLMEvent.reasoningEnd({
-            id,
-            providerMetadata: providerMetadata(event.providerMetadata),
-          }),
-        ]
-      })
-
-    case "tool-input-start":
-      return Effect.sync(() => {
-        state.toolNames[event.id] = event.toolName
-        return [
-          LLMEvent.toolInputStart({
-            id: event.id,
-            name: event.toolName,
-            providerMetadata: providerMetadata(event.providerMetadata),
-          }),
-        ]
-      })
-
-    case "tool-input-delta":
-      return Effect.succeed([
-        LLMEvent.toolInputDelta({
-          id: event.id,
-          name: state.toolNames[event.id] ?? "unknown",
-          text: event.delta ?? "",
-        }),
-      ])
-
-    case "tool-input-end":
-      return Effect.succeed([
-        LLMEvent.toolInputEnd({
-          id: event.id,
-          name: state.toolNames[event.id] ?? "unknown",
-        }),
-      ])
-
-    case "tool-call":
-      return Effect.sync(() => {
-        state.toolNames[event.toolCallId] = event.toolName
-        return [
-          LLMEvent.toolCall({
-            id: event.toolCallId,
-            name: event.toolName,
-            input: event.input,
-            providerExecuted: "providerExecuted" in event ? event.providerExecuted : undefined,
-            providerMetadata: providerMetadata(event.providerMetadata),
-          }),
-        ]
-      })
-
-    case "tool-result":
-      return Effect.sync(() => {
-        const name = state.toolNames[event.toolCallId] ?? "unknown"
-        delete state.toolNames[event.toolCallId]
-        return [
-          LLMEvent.toolResult({
-            id: event.toolCallId,
-            name,
-            result: ToolResultValue.make(event.output),
-            providerExecuted: "providerExecuted" in event ? event.providerExecuted : undefined,
-          }),
-        ]
-      })
-
-    case "tool-error":
-      return Effect.sync(() => {
-        const name = state.toolNames[event.toolCallId] ?? "unknown"
-        delete state.toolNames[event.toolCallId]
-        return [
-          LLMEvent.toolError({
-            id: event.toolCallId,
-            name,
-            message: errorMessage(event.error),
-          }),
-        ]
-      })
-
-    case "error":
-      return Effect.fail(event.error)
-
-    default:
-      return Effect.succeed([])
-  }
-}
-
-export * as LLMAISDK from "./llm-ai-sdk"

packages/opencode/src/session/llm-native.ts

@@ -1,190 +0,0 @@
-import type { JsonSchema, LLMRequest, ProviderMetadata } from "@opencode-ai/llm"
-import { LLM, Message, SystemPart, ToolCallPart, ToolDefinition, ToolResultPart } from "@opencode-ai/llm"
-import "@opencode-ai/llm/providers"
-import type { ModelMessage } from "ai"
-import type { Provider } from "@/provider/provider"
-
-type ToolInput = {
-  readonly description?: string
-  readonly inputSchema?: unknown
-}
-
-export type RequestInput = {
-  readonly model: Provider.Model
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly system?: readonly string[]
-  readonly messages: readonly ModelMessage[]
-  readonly tools?: Record<string, ToolInput>
-  readonly toolChoice?: "auto" | "required" | "none"
-  readonly temperature?: number
-  readonly topP?: number
-  readonly topK?: number
-  readonly maxOutputTokens?: number
-  readonly providerOptions?: LLMRequest["providerOptions"]
-  readonly headers?: Record<string, string>
-}
-
-const DEFAULT_BASE_URL: Record<string, string> = {
-  "@ai-sdk/openai": "https://api.openai.com/v1",
-  "@ai-sdk/anthropic": "https://api.anthropic.com/v1",
-  "@ai-sdk/google": "https://generativelanguage.googleapis.com/v1beta",
-  "@ai-sdk/amazon-bedrock": "https://bedrock-runtime.us-east-1.amazonaws.com",
-  "@openrouter/ai-sdk-provider": "https://openrouter.ai/api/v1",
-}
-
-const ROUTE: Record<string, string> = {
-  "@ai-sdk/openai": "openai-responses",
-  "@ai-sdk/azure": "azure-openai-responses",
-  "@ai-sdk/anthropic": "anthropic-messages",
-  "@ai-sdk/google": "gemini",
-  "@ai-sdk/amazon-bedrock": "bedrock-converse",
-  "@ai-sdk/openai-compatible": "openai-compatible-chat",
-  "@openrouter/ai-sdk-provider": "openrouter",
-}
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value)
-
-const providerMetadata = (value: unknown): ProviderMetadata | undefined => {
-  if (!isRecord(value)) return undefined
-  const result = Object.fromEntries(
-    Object.entries(value).filter((entry): entry is [string, Record<string, unknown>] => isRecord(entry[1])),
-  )
-  return Object.keys(result).length === 0 ? undefined : result
-}
-
-const textPart = (part: Record<string, unknown>) => ({
-  type: "text" as const,
-  text: typeof part.text === "string" ? part.text : "",
-  providerMetadata: providerMetadata(part.providerOptions),
-})
-
-const mediaPart = (part: Record<string, unknown>) => {
-  if (typeof part.data !== "string" && !(part.data instanceof Uint8Array))
-    throw new Error("Native LLM request adapter only supports file parts with string or Uint8Array data")
-  return {
-    type: "media" as const,
-    mediaType: typeof part.mediaType === "string" ? part.mediaType : "application/octet-stream",
-    data: part.data,
-    filename: typeof part.filename === "string" ? part.filename : undefined,
-  }
-}
-
-const toolResult = (part: Record<string, unknown>) => {
-  const output = isRecord(part.output) ? part.output : { type: "json", value: part.output }
-  const type = output.type === "text" ? "text" : output.type === "error-text" ? "error" : "json"
-  return ToolResultPart.make({
-    id: typeof part.toolCallId === "string" ? part.toolCallId : "",
-    name: typeof part.toolName === "string" ? part.toolName : "",
-    result: "value" in output ? output.value : output,
-    resultType: type,
-    providerExecuted: typeof part.providerExecuted === "boolean" ? part.providerExecuted : undefined,
-    providerMetadata: providerMetadata(part.providerOptions),
-  })
-}
-
-const contentPart = (part: unknown) => {
-  if (!isRecord(part)) throw new Error("Native LLM request adapter only supports object content parts")
-  if (part.type === "text") return textPart(part)
-  if (part.type === "file") return mediaPart(part)
-  if (part.type === "reasoning")
-    return {
-      type: "reasoning" as const,
-      text: typeof part.text === "string" ? part.text : "",
-      providerMetadata: providerMetadata(part.providerOptions),
-    }
-  if (part.type === "tool-call")
-    return ToolCallPart.make({
-      id: typeof part.toolCallId === "string" ? part.toolCallId : "",
-      name: typeof part.toolName === "string" ? part.toolName : "",
-      input: part.input,
-      providerExecuted: typeof part.providerExecuted === "boolean" ? part.providerExecuted : undefined,
-      providerMetadata: providerMetadata(part.providerOptions),
-    })
-  if (part.type === "tool-result") return toolResult(part)
-  throw new Error(`Native LLM request adapter does not support ${String(part.type)} content parts`)
-}
-
-const content = (value: ModelMessage["content"]) =>
-  typeof value === "string" ? [{ type: "text" as const, text: value }] : value.map(contentPart)
-
-const messages = (input: readonly ModelMessage[]) => {
-  const system = input.flatMap((message) => (message.role === "system" ? [SystemPart.make(message.content)] : []))
-  const messages = input.flatMap((message) => {
-    if (message.role === "system") return []
-    return [
-      Message.make({
-        role: message.role,
-        content: content(message.content),
-        native: isRecord(message.providerOptions) ? { providerOptions: message.providerOptions } : undefined,
-      }),
-    ]
-  })
-  return { system, messages }
-}
-
-const schema = (value: unknown): JsonSchema => {
-  if (!isRecord(value)) return { type: "object", properties: {} }
-  if (isRecord(value.jsonSchema)) return value.jsonSchema
-  return value
-}
-
-const tools = (input: Record<string, ToolInput> | undefined): ToolDefinition[] =>
-  Object.entries(input ?? {}).map(([name, item]) =>
-    ToolDefinition.make({
-      name,
-      description: item.description ?? "",
-      inputSchema: schema(item.inputSchema),
-    }),
-  )
-
-const generation = (input: RequestInput) => {
-  const result = {
-    temperature: input.temperature,
-    topP: input.topP,
-    topK: input.topK,
-    maxTokens: input.maxOutputTokens,
-  }
-  return Object.values(result).some((value) => value !== undefined) ? result : undefined
-}
-
-const baseURL = (model: Provider.Model) => {
-  if (model.api.url) return model.api.url
-  const fallback = DEFAULT_BASE_URL[model.api.npm]
-  if (fallback) return fallback
-  throw new Error(`Native LLM request adapter requires a base URL for ${model.providerID}/${model.id}`)
-}
-
-export const model = (input: Provider.Model | RequestInput, headers?: Record<string, string>) => {
-  const model = "model" in input ? input.model : input
-  const route = ROUTE[model.api.npm]
-  if (!route) throw new Error(`Native LLM request adapter does not support provider package ${model.api.npm}`)
-  return LLM.model({
-    id: model.api.id,
-    provider: model.providerID,
-    route,
-    baseURL: "model" in input && input.baseURL ? input.baseURL : baseURL(model),
-    apiKey: "model" in input ? input.apiKey : undefined,
-    headers: Object.keys({ ...model.headers, ...headers }).length === 0 ? undefined : { ...model.headers, ...headers },
-    limits: {
-      context: model.limit.context,
-      output: model.limit.output,
-    },
-  })
-}
-
-export const request = (input: RequestInput) => {
-  const converted = messages(input.messages)
-  return LLM.request({
-    model: model(input, input.headers),
-    system: [...(input.system ?? []).map(SystemPart.make), ...converted.system],
-    messages: converted.messages,
-    tools: tools(input.tools),
-    toolChoice: input.toolChoice,
-    generation: generation(input),
-    providerOptions: input.providerOptions,
-  })
-}
-
-export * as LLMNative from "./llm-native"

packages/opencode/src/session/llm.ts

@@ -2,10 +2,7 @@ import { Provider } from "@/provider/provider"
 import * as Log from "@opencode-ai/core/util/log"
 import { Context, Effect, Layer, Record } from "effect"
 import * as Stream from "effect/Stream"
-import { streamText, wrapLanguageModel, type ModelMessage, type Tool, tool as aiTool, jsonSchema, asSchema } from "ai"
-import { tool as nativeTool, ToolFailure, type JsonSchema, type LLMEvent } from "@opencode-ai/llm"
-import { LLMClient, RequestExecutor } from "@opencode-ai/llm/route"
-import type { LLMClientService } from "@opencode-ai/llm/route"
+import { streamText, wrapLanguageModel, type ModelMessage, type Tool, tool, jsonSchema } from "ai"
 import { mergeDeep } from "remeda"
 import { GitLabWorkflowLanguageModel } from "gitlab-ai-provider"
 import { ProviderTransform } from "@/provider/transform"
@@ -19,26 +16,23 @@ import { Flag } from "@opencode-ai/core/flag/flag"
 import { Permission } from "@/permission"
 import { PermissionID } from "@/permission/schema"
 import { Bus } from "@/bus"
-import { errorMessage } from "@/util/error"
 import { Wildcard } from "@/util/wildcard"
 import { SessionID } from "@/session/schema"
 import { Auth } from "@/auth"
+import { Installation } from "@/installation"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { EffectBridge } from "@/effect/bridge"
 import * as Option from "effect/Option"
 import * as OtelTracer from "@effect/opentelemetry/Tracer"
-import { LLMAISDK } from "./llm-ai-sdk"
-import { LLMNative } from "./llm-native"
 
 const log = Log.create({ service: "llm" })
 export const OUTPUT_TOKEN_MAX = ProviderTransform.OUTPUT_TOKEN_MAX
+type Result = Awaited<ReturnType<typeof streamText>>
 
 // Avoid re-instantiating remeda's deep merge types in this hot LLM path; the runtime behavior is still mergeDeep.
 const mergeOptions = (target: Record<string, any>, source: Record<string, any> | undefined): Record<string, any> =>
   mergeDeep(target, source ?? {}) as Record<string, any>
 
-const runtime = () => (process.env.OPENCODE_LLM_RUNTIME === "native" ? "native" : "ai-sdk")
-
 export type StreamInput = {
   user: MessageV2.User
   sessionID: string
@@ -58,8 +52,10 @@ export type StreamRequest = StreamInput & {
   abort: AbortSignal
 }
 
+export type Event = Result["fullStream"] extends AsyncIterable<infer T> ? T : never
+
 export interface Interface {
-  readonly stream: (input: StreamInput) => Stream.Stream<LLMEvent, unknown>
+  readonly stream: (input: StreamInput) => Stream.Stream<Event, unknown>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/LLM") {}
@@ -67,7 +63,7 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/LL
 const live: Layer.Layer<
   Service,
   never,
-  Auth.Service | Config.Service | Provider.Service | Plugin.Service | Permission.Service | LLMClientService
+  Auth.Service | Config.Service | Provider.Service | Plugin.Service | Permission.Service
 > = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -76,7 +72,6 @@ const live: Layer.Layer<
     const provider = yield* Provider.Service
     const plugin = yield* Plugin.Service
     const perm = yield* Permission.Service
-    const llmClient = yield* LLMClient.Service
 
     const run = Effect.fn("LLM.run")(function* (input: StreamRequest) {
       const l = log
@@ -219,7 +214,7 @@ const live: Layer.Layer<
         Object.keys(tools).length === 0 &&
         hasToolCalls(input.messages)
       ) {
-        tools["_noop"] = aiTool({
+        tools["_noop"] = tool({
           description: "Do not call this tool. It exists only for API compatibility and must never be invoked.",
           inputSchema: jsonSchema({
             type: "object",
@@ -339,120 +334,86 @@ const live: Layer.Layer<
         ? (yield* InstanceState.context).project.id
         : undefined
 
-      const requestHeaders = {
-        ...(input.model.providerID.startsWith("opencode")
-          ? {
-              ...(opencodeProjectID ? { "x-opencode-project": opencodeProjectID } : {}),
-              "x-opencode-session": input.sessionID,
-              "x-opencode-request": input.user.id,
-              "x-opencode-client": Flag.OPENCODE_CLIENT,
-              "User-Agent": `opencode/${InstallationVersion}`,
-            }
-          : {
-              "x-session-affinity": input.sessionID,
-              ...(input.parentSessionID ? { "x-parent-session-id": input.parentSessionID } : {}),
-              "User-Agent": `opencode/${InstallationVersion}`,
-            }),
-        ...input.model.headers,
-        ...headers,
-      }
-
-      if (runtime() === "native") {
-        if (input.model.providerID !== "openai" || input.model.api.npm !== "@ai-sdk/openai") {
-          return yield* Effect.fail(new Error("Native LLM runtime currently only supports OpenAI models"))
-        }
-        const apiKey =
-          info?.type === "api" ? info.key : typeof item.options.apiKey === "string" ? item.options.apiKey : undefined
-        if (!apiKey) return yield* Effect.fail(new Error("Native LLM runtime requires API key auth for OpenAI"))
-        const baseURL = typeof item.options.baseURL === "string" ? item.options.baseURL : undefined
-        const request = LLMNative.request({
-          model: input.model,
-          apiKey,
-          baseURL,
-          system: isOpenaiOauth ? system : [],
-          messages: ProviderTransform.message(messages, input.model, options),
-          tools: sortedTools,
-          toolChoice: input.toolChoice,
-          temperature: params.temperature,
-          topP: params.topP,
-          topK: params.topK,
-          maxOutputTokens: params.maxOutputTokens,
-          providerOptions: ProviderTransform.providerOptions(input.model, params.options),
-          headers: requestHeaders,
-        })
-        return {
-          type: "native" as const,
-          stream: llmClient.stream({ request, tools: nativeTools(sortedTools, input) }),
-        }
-      }
-
-      return {
-        type: "ai-sdk" as const,
-        result: streamText({
-          onError(error) {
-            l.error("stream error", {
-              error,
+      return streamText({
+        onError(error) {
+          l.error("stream error", {
+            error,
+          })
+        },
+        async experimental_repairToolCall(failed) {
+          const lower = failed.toolCall.toolName.toLowerCase()
+          if (lower !== failed.toolCall.toolName && sortedTools[lower]) {
+            l.info("repairing tool call", {
+              tool: failed.toolCall.toolName,
+              repaired: lower,
             })
-          },
-          async experimental_repairToolCall(failed) {
-            const lower = failed.toolCall.toolName.toLowerCase()
-            if (lower !== failed.toolCall.toolName && sortedTools[lower]) {
-              l.info("repairing tool call", {
-                tool: failed.toolCall.toolName,
-                repaired: lower,
-              })
-              return {
-                ...failed.toolCall,
-                toolName: lower,
-              }
-            }
             return {
               ...failed.toolCall,
-              input: JSON.stringify({
-                tool: failed.toolCall.toolName,
-                error: failed.error.message,
-              }),
-              toolName: "invalid",
+              toolName: lower,
             }
-          },
-          temperature: params.temperature,
-          topP: params.topP,
-          topK: params.topK,
-          providerOptions: ProviderTransform.providerOptions(input.model, params.options),
-          activeTools: Object.keys(sortedTools).filter((x) => x !== "invalid"),
-          tools: sortedTools,
-          toolChoice: input.toolChoice,
-          maxOutputTokens: params.maxOutputTokens,
-          abortSignal: input.abort,
-          headers: requestHeaders,
-          maxRetries: input.retries ?? 0,
-          messages,
-          model: wrapLanguageModel({
-            model: language,
-            middleware: [
-              {
-                specificationVersion: "v3" as const,
-                async transformParams(args) {
-                  if (args.type === "stream") {
-                    // @ts-expect-error
-                    args.params.prompt = ProviderTransform.message(args.params.prompt, input.model, options)
-                  }
-                  return args.params
-                },
+          }
+          return {
+            ...failed.toolCall,
+            input: JSON.stringify({
+              tool: failed.toolCall.toolName,
+              error: failed.error.message,
+            }),
+            toolName: "invalid",
+          }
+        },
+        temperature: params.temperature,
+        topP: params.topP,
+        topK: params.topK,
+        providerOptions: ProviderTransform.providerOptions(input.model, params.options),
+        activeTools: Object.keys(sortedTools).filter((x) => x !== "invalid"),
+        tools: sortedTools,
+        toolChoice: input.toolChoice,
+        maxOutputTokens: params.maxOutputTokens,
+        abortSignal: input.abort,
+        headers: {
+          ...(input.model.providerID.startsWith("opencode")
+            ? {
+                "x-opencode-project": opencodeProjectID,
+                "x-opencode-session": input.sessionID,
+                "x-opencode-request": input.user.id,
+                "x-opencode-client": Flag.OPENCODE_CLIENT,
+                "User-Agent": `opencode/${InstallationVersion}`,
+              }
+            : {
+                "x-session-affinity": input.sessionID,
+                ...(input.parentSessionID ? { "x-parent-session-id": input.parentSessionID } : {}),
+                "User-Agent": `opencode/${InstallationVersion}`,
+              }),
+          ...input.model.headers,
+          ...headers,
+        },
+        maxRetries: input.retries ?? 0,
+        messages,
+        model: wrapLanguageModel({
+          model: language,
+          middleware: [
+            {
+              specificationVersion: "v3" as const,
+              async transformParams(args) {
+                if (args.type === "stream") {
+                  // @ts-expect-error
+                  args.params.prompt = ProviderTransform.message(args.params.prompt, input.model, options)
+                }
+                return args.params
               },
-            ],
-          }),
-          experimental_telemetry: {
-            isEnabled: cfg.experimental?.openTelemetry,
-            functionId: "session.llm",
-            tracer: telemetryTracer,
-            metadata: {
-              userId: cfg.username ?? "unknown",
-              sessionId: input.sessionID,
             },
-          },
+          ],
         }),
-      }
+        experimental_telemetry: {
+          isEnabled: cfg.experimental?.openTelemetry,
+          functionId: "session.llm",
+          tracer: telemetryTracer,
+          metadata: {
+            userId: cfg.username ?? "unknown",
+            sessionId: input.sessionID,
+          },
+        },
+      })
     })
 
     const stream: Interface["stream"] = (input) =>
@@ -466,15 +427,7 @@ const live: Layer.Layer<
 
             const result = yield* run({ ...input, abort: ctrl.signal })
 
-            if (result.type === "native") return result.stream
-
-            const state = LLMAISDK.adapterState()
-            return Stream.fromAsyncIterable(result.result.fullStream, (e) =>
-              e instanceof Error ? e : new Error(String(e)),
-            ).pipe(
-              Stream.mapEffect((event) => LLMAISDK.toLLMEvents(state, event)),
-              Stream.flatMap((events) => Stream.fromIterable(events)),
-            )
+            return Stream.fromAsyncIterable(result.fullStream, (e) => (e instanceof Error ? e : new Error(String(e))))
           }),
         ),
       )
@@ -491,7 +444,6 @@ export const defaultLayer = Layer.suspend(() =>
     Layer.provide(Config.defaultLayer),
     Layer.provide(Provider.defaultLayer),
     Layer.provide(Plugin.defaultLayer),
-    Layer.provide(LLMClient.layer.pipe(Layer.provide(RequestExecutor.defaultLayer))),
   ),
 )
 
@@ -503,37 +455,6 @@ function resolveTools(input: Pick<StreamInput, "tools" | "agent" | "permission"
   return Record.filter(input.tools, (_, k) => input.user.tools?.[k] !== false && !disabled.has(k))
 }
 
-function nativeSchema(value: unknown): JsonSchema {
-  if (!value || typeof value !== "object") return { type: "object", properties: {} }
-  if ("jsonSchema" in value && value.jsonSchema && typeof value.jsonSchema === "object")
-    return value.jsonSchema as JsonSchema
-  return asSchema(value as Parameters<typeof asSchema>[0]).jsonSchema as JsonSchema
-}
-
-function nativeTools(tools: Record<string, Tool>, input: StreamRequest) {
-  return Object.fromEntries(
-    Object.entries(tools).map(([name, item]) => [
-      name,
-      nativeTool({
-        description: item.description ?? "",
-        jsonSchema: nativeSchema(item.inputSchema),
-        execute: (args: unknown, ctx?: { readonly id: string; readonly name: string }) =>
-          Effect.tryPromise({
-            try: () => {
-              if (!item.execute) throw new Error(`Tool has no execute handler: ${name}`)
-              return item.execute(args, {
-                toolCallId: ctx?.id ?? name,
-                messages: input.messages,
-                abortSignal: input.abort,
-              })
-            },
-            catch: (error) => new ToolFailure({ message: errorMessage(error) }),
-          }),
-      }),
-    ]),
-  )
-}
-
 // Check if messages contain any tool-call content
 // Used to determine if a dummy tool should be added for LiteLLM proxy compatibility
 export function hasToolCalls(messages: ModelMessage[]): boolean {

packages/opencode/src/session/message-error.ts

@@ -0,0 +1,14 @@
+import { Schema } from "effect"
+import { NamedError } from "@opencode-ai/core/util/error"
+
+export const OutputLengthError = NamedError.create("MessageOutputLengthError", {})
+
+export const AuthError = NamedError.create("ProviderAuthError", {
+  providerID: Schema.String,
+  message: Schema.String,
+})
+
+export const Shared = [AuthError.EffectSchema, NamedError.Unknown.EffectSchema, OutputLengthError.EffectSchema] as const
+export const SharedSchema = Schema.Union(Shared)
+
+export * as MessageError from "./message-error"

packages/opencode/src/session/message-v2.ts

@@ -23,8 +23,10 @@ import type { Provider } from "@/provider/provider"
 import { ModelID, ProviderID } from "@/provider/schema"
 import { Effect, Schema, Types } from "effect"
 import { NonNegativeInt } from "@opencode-ai/core/schema"
-import { namedSchemaError } from "@/util/named-schema-error"
 import * as EffectLogger from "@opencode-ai/core/effect/logger"
+import { MessageError } from "./message-error"
+import { AuthError, OutputLengthError } from "./message-error"
+export { AuthError, OutputLengthError } from "./message-error"
 
 /** Error shape thrown by Bun's fetch() when gzip/br decompression fails mid-stream */
 interface FetchDecompressionError extends Error {
@@ -36,17 +38,12 @@ interface FetchDecompressionError extends Error {
 export const SYNTHETIC_ATTACHMENT_PROMPT = "Attached media from tool result:"
 export { isMedia }
 
-export const OutputLengthError = namedSchemaError("MessageOutputLengthError", {})
-export const AbortedError = namedSchemaError("MessageAbortedError", { message: Schema.String })
-export const StructuredOutputError = namedSchemaError("StructuredOutputError", {
+export const AbortedError = NamedError.create("MessageAbortedError", { message: Schema.String })
+export const StructuredOutputError = NamedError.create("StructuredOutputError", {
   message: Schema.String,
   retries: NonNegativeInt,
 })
-export const AuthError = namedSchemaError("ProviderAuthError", {
-  providerID: Schema.String,
-  message: Schema.String,
-})
-export const APIError = namedSchemaError("APIError", {
+export const APIError = NamedError.create("APIError", {
   message: Schema.String,
   statusCode: Schema.optional(NonNegativeInt),
   isRetryable: Schema.Boolean,
@@ -55,7 +52,7 @@ export const APIError = namedSchemaError("APIError", {
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 })
 export type APIError = Schema.Schema.Type<typeof APIError.Schema>
-export const ContextOverflowError = namedSchemaError("ContextOverflowError", {
+export const ContextOverflowError = NamedError.create("ContextOverflowError", {
   message: Schema.String,
   responseBody: Schema.optional(Schema.String),
 })
@@ -381,9 +378,7 @@ export type Part =
   | CompactionPart
 
 const AssistantErrorSchema = Schema.Union([
-  AuthError.EffectSchema,
-  NamedError.Unknown.EffectSchema,
-  OutputLengthError.EffectSchema,
+  ...MessageError.Shared,
   AbortedError.EffectSchema,
   StructuredOutputError.EffectSchema,
   ContextOverflowError.EffectSchema,

packages/opencode/src/session/message.ts

@@ -2,14 +2,9 @@ import { Schema } from "effect"
 import { SessionID } from "./schema"
 import { ModelID, ProviderID } from "../provider/schema"
 import { NonNegativeInt } from "@opencode-ai/core/schema"
-import { namedSchemaError } from "@/util/named-schema-error"
-import { NamedError } from "@opencode-ai/core/util/error"
-
-export const OutputLengthError = namedSchemaError("MessageOutputLengthError", {})
-export const AuthError = namedSchemaError("ProviderAuthError", {
-  providerID: Schema.String,
-  message: Schema.String,
-})
+import { MessageError } from "./message-error"
+import { AuthError, OutputLengthError } from "./message-error"
+export { AuthError, OutputLengthError } from "./message-error"
 
 export const ToolCall = Schema.Struct({
   state: Schema.Literal("call"),
@@ -105,9 +100,7 @@ export const Info = Schema.Struct({
       created: NonNegativeInt,
       completed: Schema.optional(NonNegativeInt),
     }),
-    error: Schema.optional(
-      Schema.Union([AuthError.EffectSchema, NamedError.Unknown.EffectSchema, OutputLengthError.EffectSchema]),
-    ),
+    error: Schema.optional(MessageError.SharedSchema),
     sessionID: SessionID,
     tool: Schema.Record(
       Schema.String,

packages/opencode/src/session/processor.ts

@@ -1,4 +1,4 @@
-import { Cause, Deferred, Effect, Exit, Layer, Context, Scope, Schema } from "effect"
+import { Cause, Deferred, Effect, Exit, Layer, Context, Scope } from "effect"
 import * as Stream from "effect/Stream"
 import { Agent } from "@/agent/agent"
 import { Bus } from "@/bus"
@@ -26,13 +26,14 @@ import { SessionEvent } from "@/v2/session-event"
 import { Modelv2 } from "@/v2/model"
 import * as DateTime from "effect/DateTime"
 import { Flag } from "@opencode-ai/core/flag/flag"
-import { Usage, type LLMEvent } from "@opencode-ai/llm"
 
 const DOOM_LOOP_THRESHOLD = 3
 const log = Log.create({ service: "session.processor" })
 
 export type Result = "compact" | "stop" | "continue"
 
+export type Event = LLM.Event
+
 export interface Handle {
   readonly message: MessageV2.Assistant
   readonly updateToolCall: (
@@ -66,7 +67,6 @@ type ToolCall = {
   messageID: MessageV2.ToolPart["messageID"]
   sessionID: MessageV2.ToolPart["sessionID"]
   done: Deferred.Deferred<void>
-  inputEnded: boolean
 }
 
 interface ProcessorContext extends Input {
@@ -79,7 +79,7 @@ interface ProcessorContext extends Input {
   reasoningMap: Record<string, MessageV2.ReasoningPart>
 }
 
-type StreamEvent = LLMEvent
+type StreamEvent = Event
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/SessionProcessor") {}
 
@@ -223,85 +223,9 @@ export const layer: Layer.Layer<
         return true
       })
 
-      const finishReasoning = Effect.fn("SessionProcessor.finishReasoning")(function* (reasoningID: string) {
-        if (!(reasoningID in ctx.reasoningMap)) return
-        // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
-        if (Flag.OPENCODE_EXPERIMENTAL_EVENT_SYSTEM) {
-          yield* sync.run(SessionEvent.Reasoning.Ended.Sync, {
-            sessionID: ctx.sessionID,
-            reasoningID,
-            text: ctx.reasoningMap[reasoningID].text,
-            timestamp: DateTime.makeUnsafe(Date.now()),
-          })
-        }
-        // oxlint-disable-next-line no-self-assign -- reactivity trigger
-        ctx.reasoningMap[reasoningID].text = ctx.reasoningMap[reasoningID].text
-        ctx.reasoningMap[reasoningID].time = { ...ctx.reasoningMap[reasoningID].time, end: Date.now() }
-        yield* session.updatePart(ctx.reasoningMap[reasoningID])
-        delete ctx.reasoningMap[reasoningID]
-      })
-
-      const ensureToolCall = Effect.fn("SessionProcessor.ensureToolCall")(function* (input: {
-        id: string
-        name: string
-        providerExecuted?: boolean
-      }) {
-        const existing = yield* readToolCall(input.id)
-        if (existing) return existing
-        // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
-        if (Flag.OPENCODE_EXPERIMENTAL_EVENT_SYSTEM) {
-          yield* sync.run(SessionEvent.Tool.Input.Started.Sync, {
-            sessionID: ctx.sessionID,
-            callID: input.id,
-            name: input.name,
-            timestamp: DateTime.makeUnsafe(Date.now()),
-          })
-        }
-        const part = yield* session.updatePart({
-          id: PartID.ascending(),
-          messageID: ctx.assistantMessage.id,
-          sessionID: ctx.assistantMessage.sessionID,
-          type: "tool",
-          tool: input.name,
-          callID: input.id,
-          state: { status: "pending", input: {}, raw: "" },
-          metadata: input.providerExecuted ? { providerExecuted: true } : undefined,
-        } satisfies MessageV2.ToolPart)
-        ctx.toolcalls[input.id] = {
-          done: yield* Deferred.make<void>(),
-          partID: part.id,
-          messageID: part.messageID,
-          sessionID: part.sessionID,
-          inputEnded: false,
-        }
-        return { call: ctx.toolcalls[input.id], part }
-      })
-
-      const isFilePart = Schema.is(MessageV2.FilePart)
-
-      const toolResultOutput = (value: Extract<StreamEvent, { type: "tool-result" }>) => {
-        if (isRecord(value.result.value) && typeof value.result.value.output === "string") {
-          return {
-            title: typeof value.result.value.title === "string" ? value.result.value.title : value.name,
-            metadata: isRecord(value.result.value.metadata) ? value.result.value.metadata : {},
-            output: value.result.value.output,
-            attachments: Array.isArray(value.result.value.attachments)
-              ? value.result.value.attachments.filter(isFilePart)
-              : undefined,
-          }
-        }
-        return {
-          title: value.name,
-          metadata: value.result.type === "json" && isRecord(value.result.value) ? value.result.value : {},
-          output: typeof value.result.value === "string" ? value.result.value : (JSON.stringify(value.result.value) ?? ""),
-        }
-      }
-
-      const toolInput = (value: unknown): Record<string, any> => (isRecord(value) ? value : { value })
-
       const handleEvent = Effect.fnUntraced(function* (value: StreamEvent) {
         switch (value.type) {
-          case "request-start":
+          case "start":
             yield* status.set(ctx.sessionID, { type: "busy" })
             return
 
@@ -327,132 +251,116 @@ export const layer: Layer.Layer<
             yield* session.updatePart(ctx.reasoningMap[value.id])
             return
 
-          case "reasoning-delta": {
-            const reasoningID = value.id ?? "reasoning"
-            if (!(reasoningID in ctx.reasoningMap)) {
-              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
-              if (Flag.OPENCODE_EXPERIMENTAL_EVENT_SYSTEM) {
-                yield* sync.run(SessionEvent.Reasoning.Started.Sync, {
-                  sessionID: ctx.sessionID,
-                  reasoningID,
-                  timestamp: DateTime.makeUnsafe(Date.now()),
-                })
-              }
-              ctx.reasoningMap[reasoningID] = {
-                id: PartID.ascending(),
-                messageID: ctx.assistantMessage.id,
-                sessionID: ctx.assistantMessage.sessionID,
-                type: "reasoning",
-                text: "",
-                time: { start: Date.now() },
-              }
-              yield* session.updatePart(ctx.reasoningMap[reasoningID])
-            }
-            ctx.reasoningMap[reasoningID].text += value.text
+          case "reasoning-delta":
+            if (!(value.id in ctx.reasoningMap)) return
+            ctx.reasoningMap[value.id].text += value.text
+            if (value.providerMetadata) ctx.reasoningMap[value.id].metadata = value.providerMetadata
             yield* session.updatePartDelta({
-              sessionID: ctx.reasoningMap[reasoningID].sessionID,
-              messageID: ctx.reasoningMap[reasoningID].messageID,
-              partID: ctx.reasoningMap[reasoningID].id,
+              sessionID: ctx.reasoningMap[value.id].sessionID,
+              messageID: ctx.reasoningMap[value.id].messageID,
+              partID: ctx.reasoningMap[value.id].id,
               field: "text",
               delta: value.text,
             })
             return
-          }
 
           case "reasoning-end":
-            if (value.providerMetadata && value.id in ctx.reasoningMap) {
-              ctx.reasoningMap[value.id].metadata = value.providerMetadata
+            if (!(value.id in ctx.reasoningMap)) return
+            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+            if (Flag.OPENCODE_EXPERIMENTAL_EVENT_SYSTEM) {
+              yield* sync.run(SessionEvent.Reasoning.Ended.Sync, {
+                sessionID: ctx.sessionID,
+                reasoningID: value.id,
+                text: ctx.reasoningMap[value.id].text,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
             }
-            yield* finishReasoning(value.id)
+            // oxlint-disable-next-line no-self-assign -- reactivity trigger
+            ctx.reasoningMap[value.id].text = ctx.reasoningMap[value.id].text
+            ctx.reasoningMap[value.id].time = { ...ctx.reasoningMap[value.id].time, end: Date.now() }
+            if (value.providerMetadata) ctx.reasoningMap[value.id].metadata = value.providerMetadata
+            yield* session.updatePart(ctx.reasoningMap[value.id])
+            delete ctx.reasoningMap[value.id]
             return
 
           case "tool-input-start":
             if (ctx.assistantMessage.summary) {
-              throw new Error(`Tool call not allowed while generating summary: ${value.name}`)
+              throw new Error(`Tool call not allowed while generating summary: ${value.toolName}`)
+            }
+            // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
+            if (Flag.OPENCODE_EXPERIMENTAL_EVENT_SYSTEM) {
+              yield* sync.run(SessionEvent.Tool.Input.Started.Sync, {
+                sessionID: ctx.sessionID,
+                callID: value.id,
+                name: value.toolName,
+                timestamp: DateTime.makeUnsafe(Date.now()),
+              })
+            }
+            const part = yield* session.updatePart({
+              id: ctx.toolcalls[value.id]?.partID ?? PartID.ascending(),
+              messageID: ctx.assistantMessage.id,
+              sessionID: ctx.assistantMessage.sessionID,
+              type: "tool",
+              tool: value.toolName,
+              callID: value.id,
+              state: { status: "pending", input: {}, raw: "" },
+              metadata: value.providerExecuted ? { providerExecuted: true } : undefined,
+            } satisfies MessageV2.ToolPart)
+            ctx.toolcalls[value.id] = {
+              done: yield* Deferred.make<void>(),
+              partID: part.id,
+              messageID: part.messageID,
+              sessionID: part.sessionID,
             }
-            yield* ensureToolCall(value)
             return
 
-          case "tool-input-delta": {
-            if (ctx.assistantMessage.summary) {
-              throw new Error(`Tool call not allowed while generating summary: ${value.name}`)
-            }
-            yield* ensureToolCall(value)
-            if (value.text) {
-              yield* updateToolCall(value.id, (match) => ({
-                ...match,
-                state:
-                  match.state.status === "pending"
-                    ? { ...match.state, raw: match.state.raw + value.text }
-                    : match.state,
-              }))
-            }
+          case "tool-input-delta":
             return
-          }
 
           case "tool-input-end": {
-            const toolCall = yield* ensureToolCall(value)
             // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
             if (Flag.OPENCODE_EXPERIMENTAL_EVENT_SYSTEM) {
               yield* sync.run(SessionEvent.Tool.Input.Ended.Sync, {
                 sessionID: ctx.sessionID,
                 callID: value.id,
-                text: toolCall.part.state.status === "pending" ? toolCall.part.state.raw : "",
+                text: "",
                 timestamp: DateTime.makeUnsafe(Date.now()),
               })
             }
-            ctx.toolcalls[value.id] = { ...toolCall.call, inputEnded: true }
             return
           }
 
           case "tool-call": {
             if (ctx.assistantMessage.summary) {
-              throw new Error(`Tool call not allowed while generating summary: ${value.name}`)
-            }
-            const toolCall = yield* ensureToolCall(value)
-            const input = toolInput(value.input)
-            const raw = toolCall.part.state.status === "pending" ? toolCall.part.state.raw : ""
-            if (!toolCall.call.inputEnded) {
-              // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
-              if (Flag.OPENCODE_EXPERIMENTAL_EVENT_SYSTEM) {
-                yield* sync.run(SessionEvent.Tool.Input.Ended.Sync, {
-                  sessionID: ctx.sessionID,
-                  callID: value.id,
-                  text: raw,
-                  timestamp: DateTime.makeUnsafe(Date.now()),
-                })
-              }
+              throw new Error(`Tool call not allowed while generating summary: ${value.toolName}`)
             }
+            const toolCall = yield* readToolCall(value.toolCallId)
             // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
             if (Flag.OPENCODE_EXPERIMENTAL_EVENT_SYSTEM) {
               yield* sync.run(SessionEvent.Tool.Called.Sync, {
                 sessionID: ctx.sessionID,
-                callID: value.id,
-                tool: value.name,
-                input,
+                callID: value.toolCallId,
+                tool: value.toolName,
+                input: value.input,
                 provider: {
-                  executed: toolCall.part.metadata?.providerExecuted === true,
+                  executed: toolCall?.part.metadata?.providerExecuted === true,
                   ...(value.providerMetadata ? { metadata: value.providerMetadata } : {}),
                 },
                 timestamp: DateTime.makeUnsafe(Date.now()),
               })
             }
-            yield* updateToolCall(value.id, (match) => ({
+            yield* updateToolCall(value.toolCallId, (match) => ({
               ...match,
-              tool: value.name,
-              state:
-                match.state.status === "running"
-                  ? { ...match.state, input }
-                  : {
-                      status: "running",
-                      input,
-                      time: { start: Date.now() },
-                    },
-              metadata: {
-                ...match.metadata,
-                ...value.providerMetadata,
-                ...(match.metadata?.providerExecuted ? { providerExecuted: true } : {}),
+              tool: value.toolName,
+              state: {
+                ...match.state,
+                status: "running",
+                input: value.input,
+                time: { start: Date.now() },
               },
+              metadata: match.metadata?.providerExecuted
+                ? { ...value.providerMetadata, providerExecuted: true }
+                : value.providerMetadata,
             }))
 
             const parts = MessageV2.parts(ctx.assistantMessage.id)
@@ -463,9 +371,9 @@ export const layer: Layer.Layer<
               !recentParts.every(
                 (part) =>
                   part.type === "tool" &&
-                  part.tool === value.name &&
+                  part.tool === value.toolName &&
                   part.state.status !== "pending" &&
-                  JSON.stringify(part.state.input) === JSON.stringify(input),
+                  JSON.stringify(part.state.input) === JSON.stringify(value.input),
               )
             ) {
               return
@@ -474,19 +382,27 @@ export const layer: Layer.Layer<
             const agent = yield* agents.get(ctx.assistantMessage.agent)
             yield* permission.ask({
               permission: "doom_loop",
-              patterns: [value.name],
+              patterns: [value.toolName],
               sessionID: ctx.assistantMessage.sessionID,
-              metadata: { tool: value.name, input },
-              always: [value.name],
+              metadata: { tool: value.toolName, input: value.input },
+              always: [value.toolName],
               ruleset: agent.permission,
             })
             return
           }
 
           case "tool-result": {
-            const toolCall = yield* readToolCall(value.id)
-            const rawOutput = toolResultOutput(value)
-            const normalized = yield* Effect.forEach(rawOutput.attachments ?? [], (attachment) =>
+            const toolCall = yield* readToolCall(value.toolCallId)
+            const toolAttachments: MessageV2.FilePart[] = (
+              Array.isArray(value.output.attachments) ? value.output.attachments : []
+            ).filter(
+              (attachment: unknown): attachment is MessageV2.FilePart =>
+                isRecord(attachment) &&
+                attachment.type === "file" &&
+                typeof attachment.mime === "string" &&
+                typeof attachment.url === "string",
+            )
+            const normalized = yield* Effect.forEach(toolAttachments, (attachment) =>
               attachment.mime.startsWith("image/")
                 ? image.normalize(attachment).pipe(Effect.exit)
                 : Effect.succeed(Exit.succeed<MessageV2.FilePart>(attachment)),
@@ -494,18 +410,18 @@ export const layer: Layer.Layer<
             const omitted = normalized.filter(Exit.isFailure).length
             const attachments = normalized.filter(Exit.isSuccess).map((item) => item.value)
             const output = {
-              ...rawOutput,
+              ...value.output,
               output:
                 omitted === 0
-                  ? rawOutput.output
-                  : `${rawOutput.output}\n\n[${omitted} image${omitted === 1 ? "" : "s"} omitted: could not be resized below the inline image size limit.]`,
-              attachments: attachments.length ? attachments : undefined,
+                  ? value.output.output
+                  : `${value.output.output}\n\n[${omitted} image${omitted === 1 ? "" : "s"} omitted: could not be resized below the inline image size limit.]`,
+              attachments: attachments?.length ? attachments : undefined,
             }
             // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
             if (Flag.OPENCODE_EXPERIMENTAL_EVENT_SYSTEM) {
               yield* sync.run(SessionEvent.Tool.Success.Sync, {
                 sessionID: ctx.sessionID,
-                callID: value.id,
+                callID: value.toolCallId,
                 structured: output.metadata,
                 content: [
                   {
@@ -513,32 +429,32 @@ export const layer: Layer.Layer<
                     text: output.output,
                   },
                   ...(output.attachments?.map((item: MessageV2.FilePart) => ({
-                    type: "file" as const,
+                    type: "file",
                     uri: item.url,
                     mime: item.mime,
                     name: item.filename,
                   })) ?? []),
                 ],
                 provider: {
-                  executed: value.providerExecuted === true || toolCall?.part.metadata?.providerExecuted === true,
+                  executed: toolCall?.part.metadata?.providerExecuted === true,
                 },
                 timestamp: DateTime.makeUnsafe(Date.now()),
               })
             }
-            yield* completeToolCall(value.id, output)
+            yield* completeToolCall(value.toolCallId, output)
             return
           }
 
           case "tool-error": {
-            const toolCall = yield* readToolCall(value.id)
+            const toolCall = yield* readToolCall(value.toolCallId)
             // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
             if (Flag.OPENCODE_EXPERIMENTAL_EVENT_SYSTEM) {
               yield* sync.run(SessionEvent.Tool.Failed.Sync, {
                 sessionID: ctx.sessionID,
-                callID: value.id,
+                callID: value.toolCallId,
                 error: {
                   type: "unknown",
-                  message: value.message,
+                  message: errorMessage(value.error),
                 },
                 provider: {
                   executed: toolCall?.part.metadata?.providerExecuted === true,
@@ -546,14 +462,14 @@ export const layer: Layer.Layer<
                 timestamp: DateTime.makeUnsafe(Date.now()),
               })
             }
-            yield* failToolCall(value.id, new Error(value.message))
+            yield* failToolCall(value.toolCallId, value.error)
             return
           }
 
-          case "provider-error":
-            throw new Error(value.message)
+          case "error":
+            throw value.error
 
-          case "step-start":
+          case "start-step":
             if (!ctx.snapshot) ctx.snapshot = yield* snapshot.track()
             if (!ctx.assistantMessage.summary) {
               // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
@@ -580,20 +496,19 @@ export const layer: Layer.Layer<
             })
             return
 
-          case "step-finish": {
+          case "finish-step": {
             const completedSnapshot = yield* snapshot.track()
-            yield* Effect.forEach(Object.keys(ctx.reasoningMap), finishReasoning)
-              const usage = Session.getUsage({
-                model: ctx.model,
-                usage: value.usage ?? new Usage({}),
-                metadata: value.providerMetadata,
-              })
+            const usage = Session.getUsage({
+              model: ctx.model,
+              usage: value.usage,
+              metadata: value.providerMetadata,
+            })
             if (!ctx.assistantMessage.summary) {
               // TODO(v2): Temporary dual-write while migrating session messages to v2 events.
               if (Flag.OPENCODE_EXPERIMENTAL_EVENT_SYSTEM) {
                 yield* sync.run(SessionEvent.Step.Ended.Sync, {
                   sessionID: ctx.sessionID,
-                  finish: value.reason,
+                  finish: value.finishReason,
                   cost: usage.cost,
                   tokens: usage.tokens,
                   snapshot: completedSnapshot,
@@ -601,12 +516,12 @@ export const layer: Layer.Layer<
                 })
               }
             }
-            ctx.assistantMessage.finish = value.reason
+            ctx.assistantMessage.finish = value.finishReason
             ctx.assistantMessage.cost += usage.cost
             ctx.assistantMessage.tokens = usage.tokens
             yield* session.updatePart({
               id: PartID.ascending(),
-              reason: value.reason,
+              reason: value.finishReason,
               snapshot: completedSnapshot,
               messageID: ctx.assistantMessage.id,
               sessionID: ctx.assistantMessage.sessionID,
@@ -669,6 +584,7 @@ export const layer: Layer.Layer<
           case "text-delta":
             if (!ctx.currentText) return
             ctx.currentText.text += value.text
+            if (value.providerMetadata) ctx.currentText.metadata = value.providerMetadata
             yield* session.updatePartDelta({
               sessionID: ctx.currentText.sessionID,
               messageID: ctx.currentText.messageID,
@@ -710,9 +626,12 @@ export const layer: Layer.Layer<
             ctx.currentText = undefined
             return
 
-          case "request-finish":
+          case "finish":
             return
 
+          default:
+            slog.info("unhandled", { event: value.type, value })
+            return
         }
       })
 
@@ -814,7 +733,6 @@ export const layer: Layer.Layer<
           yield* Effect.gen(function* () {
             ctx.currentText = undefined
             ctx.reasoningMap = {}
-            yield* status.set(ctx.sessionID, { type: "busy" })
             const stream = llm.stream(streamInput)
 
             yield* stream.pipe(
@@ -898,12 +816,12 @@ export const defaultLayer = Layer.suspend(() =>
     Layer.provide(LLM.defaultLayer),
     Layer.provide(Permission.defaultLayer),
     Layer.provide(Plugin.defaultLayer),
-    Layer.provide(Image.defaultLayer),
     Layer.provide(SessionSummary.defaultLayer),
     Layer.provide(SessionStatus.defaultLayer),
-    Layer.provide(SyncEvent.defaultLayer),
+    Layer.provide(Image.defaultLayer),
     Layer.provide(Bus.layer),
     Layer.provide(Config.defaultLayer),
+    Layer.provide(SyncEvent.defaultLayer),
   ),
 )
 

packages/opencode/src/session/projectors.ts

@@ -38,6 +38,7 @@ function applyUsage(db: TxOrDb, sessionID: Session.Info["id"], value: Usage, sig
       tokens_reasoning: sql`${SessionTable.tokens_reasoning} + ${value.tokens.reasoning * sign}`,
       tokens_cache_read: sql`${SessionTable.tokens_cache_read} + ${value.tokens.cache.read * sign}`,
       tokens_cache_write: sql`${SessionTable.tokens_cache_write} + ${value.tokens.cache.write * sign}`,
+      time_updated: sql`${SessionTable.time_updated}`,
     })
     .where(eq(SessionTable.id, sessionID))
     .run()
@@ -110,7 +111,7 @@ export default [
     const info = data.info
     const row = db
       .update(SessionTable)
-      .set(toPartialRow(info as Session.Patch))
+      .set({ time_updated: sql`${SessionTable.time_updated}`, ...toPartialRow(info as Session.Patch) })
       .where(eq(SessionTable.id, data.sessionID))
       .returning()
       .get()

packages/opencode/src/session/prompt.ts

@@ -60,7 +60,6 @@ import * as DateTime from "effect/DateTime"
 import { eq } from "@/storage/db"
 import * as Database from "@/storage/db"
 import { SessionTable } from "./session.sql"
-import { LLMEvent } from "@opencode-ai/llm"
 
 // @ts-ignore
 globalThis.AI_SDK_LOG_WARNINGS = false
@@ -360,7 +359,7 @@ export const layer = Layer.effect(
           messages: [{ role: "user", content: "Generate a title for this conversation:\n" }, ...msgs],
         })
         .pipe(
-          Stream.filter(LLMEvent.is.textDelta),
+          Stream.filter((e): e is Extract<LLM.Event, { type: "text-delta" }> => e.type === "text-delta"),
           Stream.map((e) => e.text),
           Stream.mkString,
           Effect.orDie,
@@ -1084,8 +1083,8 @@ NOTE: At any point in time through this workflow you should feel free to ask the
     })
 
     const createUserMessage = Effect.fn("SessionPrompt.createUserMessage")(function* (input: PromptInput) {
-      const agentName = input.agent || (yield* agents.defaultAgent())
-      const ag = yield* agents.get(agentName)
+      const agentName = input.agent
+      const ag = agentName ? yield* agents.get(agentName) : yield* agents.defaultInfo()
       if (!ag) {
         const available = (yield* agents.list()).filter((a) => !a.hidden).map((a) => a.name)
         const hint = available.length ? ` Available agents: ${available.join(", ")}` : ""
@@ -1876,7 +1875,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
         yield* bus.publish(Session.Event.Error, { sessionID: input.sessionID, error: error.toObject() })
         throw error
       }
-      const agentName = cmd.agent ?? input.agent ?? (yield* agents.defaultAgent())
+      const agentName = cmd.agent ?? input.agent
 
       const raw = input.arguments.match(argsRegex) ?? []
       const args = raw.map((arg) => arg.replace(quoteTrimRegex, ""))
@@ -1929,7 +1928,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 
       yield* getModel(taskModel.providerID, taskModel.modelID, input.sessionID)
 
-      const agent = yield* agents.get(agentName)
+      const agent = agentName ? yield* agents.get(agentName) : yield* agents.defaultInfo()
       if (!agent) {
         const available = (yield* agents.list()).filter((a) => !a.hidden).map((a) => a.name)
         const hint = available.length ? ` Available agents: ${available.join(", ")}` : ""
@@ -1953,7 +1952,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
           ]
         : [...templateParts, ...(input.parts ?? [])]
 
-      const userAgent = isSubtask ? (input.agent ?? (yield* agents.defaultAgent())) : agentName
+      const userAgent = isSubtask ? (input.agent ?? (yield* agents.defaultInfo()).name) : agent.name
       const userModel = isSubtask
         ? input.model
           ? Provider.parseModel(input.model)

packages/opencode/src/session/session.ts

@@ -3,7 +3,7 @@ import path from "path"
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
 import { Decimal } from "decimal.js"
-import type { ProviderMetadata, Usage } from "@opencode-ai/llm"
+import { type ProviderMetadata, type LanguageModelUsage } from "ai"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 
@@ -373,19 +373,21 @@ export function plan(input: { slug: string; time: { created: number } }, instanc
   return path.join(base, [input.time.created, input.slug].join("-") + ".md")
 }
 
-export const getUsage = (input: { model: Provider.Model; usage: Usage; metadata?: ProviderMetadata }) => {
+export const getUsage = (input: { model: Provider.Model; usage: LanguageModelUsage; metadata?: ProviderMetadata }) => {
   const safe = (value: number) => {
     if (!Number.isFinite(value)) return 0
     return Math.max(0, value)
   }
   const inputTokens = safe(input.usage.inputTokens ?? 0)
   const outputTokens = safe(input.usage.outputTokens ?? 0)
-  const reasoningTokens = safe(input.usage.reasoningTokens ?? 0)
+  const reasoningTokens = safe(input.usage.outputTokenDetails?.reasoningTokens ?? input.usage.reasoningTokens ?? 0)
 
-  const cacheReadInputTokens = safe(input.usage.cacheReadInputTokens ?? 0)
+  const cacheReadInputTokens = safe(
+    input.usage.inputTokenDetails?.cacheReadTokens ?? input.usage.cachedInputTokens ?? 0,
+  )
   const cacheWriteInputTokens = safe(
     Number(
-      input.usage.cacheWriteInputTokens ??
+      input.usage.inputTokenDetails?.cacheWriteTokens ??
         input.metadata?.["anthropic"]?.["cacheCreationInputTokens"] ??
         // google-vertex-anthropic returns metadata under "vertex" key
         // (AnthropicMessagesLanguageModel custom provider key from 'vertex.anthropic.messages')

packages/opencode/src/util/named-schema-error.ts

@@ -1,9 +0,0 @@
-import { Schema } from "effect"
-import { NamedError } from "@opencode-ai/core/util/error"
-
-/**
- * Create a Schema-backed NamedError-shaped class.
- */
-export function namedSchemaError<Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) {
-  return NamedError.create(tag, fields)
-}

packages/opencode/test/agent/plan-mode-subagent-bypass.test.ts

@@ -18,110 +18,85 @@
  * permissions are passed through, and Plan Mode's restrictions live on the
  * agent, not the session.
  */
-import { test, expect, afterEach } from "bun:test"
+import { expect } from "bun:test"
 import { Effect } from "effect"
-import { disposeAllInstances, provideInstance, tmpdir } from "../fixture/fixture"
-import { WithInstance } from "../../src/project/with-instance"
 import { Agent } from "../../src/agent/agent"
 import { deriveSubagentSessionPermission } from "../../src/agent/subagent-permissions"
 import { Permission } from "../../src/permission"
+import { testEffect } from "../lib/effect"
 
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-function load<A>(dir: string, fn: (svc: Agent.Interface) => Effect.Effect<A>) {
-  return Effect.runPromise(provideInstance(dir)(Agent.Service.use(fn)).pipe(Effect.provide(Agent.defaultLayer)))
-}
+const it = testEffect(Agent.defaultLayer)
 
 // `deriveSubagentSessionPermission` is imported from production. The test
 // exercises the actual helper that task.ts uses to build the subagent's
 // session permission, so any regression in that helper trips this test.
 
-test("[#26514] subagent spawned from plan mode inherits read-only restriction (edit denied)", async () => {
-  await using tmp = await tmpdir()
-  await WithInstance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const planAgent = await load(tmp.path, (svc) => svc.get("plan"))
-      const generalAgent = await load(tmp.path, (svc) => svc.get("general"))
+it.instance("[#26514] subagent spawned from plan mode inherits read-only restriction (edit denied)", () =>
+  Effect.gen(function* () {
+    const planAgent = yield* Agent.Service.use((svc) => svc.get("plan"))
+    const generalAgent = yield* Agent.Service.use((svc) => svc.get("general"))
 
-      expect(planAgent).toBeDefined()
-      expect(generalAgent).toBeDefined()
-      // Sanity: the plan agent itself blocks edit. (Note: `write` and
-      // `apply_patch` route through the `edit` permission at the runtime
-      // tool layer — see Permission.disabled / EDIT_TOOLS.)
-      expect(Permission.evaluate("edit", "/some/file.ts", planAgent!.permission).action).toBe("deny")
+    expect(planAgent).toBeDefined()
+    expect(generalAgent).toBeDefined()
+    // Sanity: the plan agent itself blocks edit. (Note: `write` and
+    // `apply_patch` route through the `edit` permission at the runtime
+    // tool layer — see Permission.disabled / EDIT_TOOLS.)
+    expect(Permission.evaluate("edit", "/some/file.ts", planAgent!.permission).action).toBe("deny")
 
-      // Simulate the plan-mode parent session: in real flow the plan
-      // session's `permission` field is empty (Plan Mode lives on the agent
-      // ruleset, not the session). So we pass [] through as the parent
-      // session permission, exactly like the actual code path.
-      const parentSessionPermission: Permission.Ruleset = []
+    // Simulate the plan-mode parent session: in real flow the plan
+    // session's `permission` field is empty (Plan Mode lives on the agent
+    // ruleset, not the session). So we pass [] through as the parent
+    // session permission, exactly like the actual code path.
+    const parentSessionPermission: Permission.Ruleset = []
 
-      const subagentSessionPermission = deriveSubagentSessionPermission({
-        parentSessionPermission,
-        parentAgent: planAgent,
-        subagent: generalAgent!,
-      })
+    const subagentSessionPermission = deriveSubagentSessionPermission({
+      parentSessionPermission,
+      parentAgent: planAgent,
+      subagent: generalAgent!,
+    })
 
-      // Mirror the runtime evaluation in session/prompt.ts (~line 410, 639):
-      //   ruleset: Permission.merge(agent.permission, session.permission ?? [])
-      const effective = Permission.merge(generalAgent!.permission, subagentSessionPermission)
+    // Mirror the runtime evaluation in session/prompt.ts (~line 410, 639):
+    //   ruleset: Permission.merge(agent.permission, session.permission ?? [])
+    const effective = Permission.merge(generalAgent!.permission, subagentSessionPermission)
 
-      expect(Permission.evaluate("edit", "/some/file.ts", effective).action).toBe("deny")
-      expect(Permission.evaluate("edit", "/another/path/index.tsx", effective).action).toBe("deny")
-    },
-  })
-})
+    expect(Permission.evaluate("edit", "/some/file.ts", effective).action).toBe("deny")
+    expect(Permission.evaluate("edit", "/another/path/index.tsx", effective).action).toBe("deny")
+  }),
+)
 
-test("[#26514] explore subagent launched from plan mode also stays read-only", async () => {
+it.instance("[#26514] explore subagent launched from plan mode also stays read-only", () =>
   // Sibling check: even though `explore` is intrinsically read-only, the
   // bug surface is the same. Including this case to document that the fix
   // should propagate the parent **agent** permissions, not just deny edit
   // when the subagent happens to already deny it.
-  await using tmp = await tmpdir()
-  await WithInstance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const planAgent = await load(tmp.path, (svc) => svc.get("plan"))
-      const explore = await load(tmp.path, (svc) => svc.get("explore"))
-      expect(planAgent).toBeDefined()
-      expect(explore).toBeDefined()
+  Effect.gen(function* () {
+    const planAgent = yield* Agent.Service.use((svc) => svc.get("plan"))
+    const explore = yield* Agent.Service.use((svc) => svc.get("explore"))
+    expect(planAgent).toBeDefined()
+    expect(explore).toBeDefined()
 
-      const parentSessionPermission: Permission.Ruleset = []
-      const subagentSessionPermission = deriveSubagentSessionPermission({
-        parentSessionPermission,
-        parentAgent: planAgent,
-        subagent: explore!,
-      })
-      const effective = Permission.merge(explore!.permission, subagentSessionPermission)
+    const parentSessionPermission: Permission.Ruleset = []
+    const subagentSessionPermission = deriveSubagentSessionPermission({
+      parentSessionPermission,
+      parentAgent: planAgent,
+      subagent: explore!,
+    })
+    const effective = Permission.merge(explore!.permission, subagentSessionPermission)
 
-      // Already deny — sanity check.
-      expect(Permission.evaluate("edit", "/x.ts", effective).action).toBe("deny")
-    },
-  })
-})
+    // Already deny — sanity check.
+    expect(Permission.evaluate("edit", "/x.ts", effective).action).toBe("deny")
+  }),
+)
 
-test("[#26514] custom user subagent launched from plan mode bypasses Plan Mode read-only", async () => {
+it.instance(
+  "[#26514] custom user subagent launched from plan mode bypasses Plan Mode read-only",
   // The most damaging case: a user-defined subagent with default
   // permissions (allow-by-default, like `general`). The subagent must NOT
   // be able to edit when the parent agent is `plan`.
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        my_subagent: {
-          description: "A user-defined subagent",
-          mode: "subagent",
-        },
-      },
-    },
-  })
-  await WithInstance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const planAgent = await load(tmp.path, (svc) => svc.get("plan"))
-      const my = await load(tmp.path, (svc) => svc.get("my_subagent"))
+  () =>
+    Effect.gen(function* () {
+      const planAgent = yield* Agent.Service.use((svc) => svc.get("plan"))
+      const my = yield* Agent.Service.use((svc) => svc.get("my_subagent"))
       expect(planAgent).toBeDefined()
       expect(my).toBeDefined()
 
@@ -136,6 +111,15 @@ test("[#26514] custom user subagent launched from plan mode bypasses Plan Mode r
       // BUG: on origin/dev edit resolves to "allow" because the plan
       // agent's `edit: deny *` rule never reaches the subagent.
       expect(Permission.evaluate("edit", "/some/file.ts", effective).action).toBe("deny")
+    }),
+  {
+    config: {
+      agent: {
+        my_subagent: {
+          description: "A user-defined subagent",
+          mode: "subagent",
+        },
+      },
     },
-  })
-})
+  },
+)

packages/opencode/test/bus/bus-integration.test.ts

@@ -1,88 +1,88 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Schema } from "effect"
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+import { afterEach, describe, expect } from "bun:test"
+import { Deferred, Effect, Layer, Schema } from "effect"
 import { Bus } from "../../src/bus"
 import { BusEvent } from "../../src/bus/bus-event"
-import { Instance } from "../../src/project/instance"
-import { WithInstance } from "../../src/project/with-instance"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
+import { disposeAllInstances, provideInstance, tmpdirScoped } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
 
 const TestEvent = BusEvent.define("test.integration", Schema.Struct({ value: Schema.Number }))
-
-function withInstance(directory: string, fn: () => Promise<void>) {
-  return WithInstance.provide({ directory, fn })
-}
+const it = testEffect(Layer.mergeAll(Bus.layer, CrossSpawnSpawner.defaultLayer))
 
 describe("Bus integration: acquireRelease subscriber pattern", () => {
   afterEach(() => disposeAllInstances())
 
-  test("subscriber via callback facade receives events and cleans up on unsub", async () => {
-    await using tmp = await tmpdir()
-    const received: number[] = []
+  it.instance("subscriber via callback facade receives events and cleans up on unsub", () =>
+    Effect.gen(function* () {
+      const bus = yield* Bus.Service
+      const received: number[] = []
+      const receivedTwo = yield* Deferred.make<void>()
 
-    await withInstance(tmp.path, async () => {
-      const unsub = Bus.subscribe(TestEvent, (evt) => {
+      const unsub = yield* bus.subscribeCallback(TestEvent, (evt) => {
         received.push(evt.properties.value)
+        if (received.length === 2) Deferred.doneUnsafe(receivedTwo, Effect.void)
       })
-      await Bun.sleep(10)
-      await Bus.publish(TestEvent, { value: 1 })
-      await Bus.publish(TestEvent, { value: 2 })
-      await Bun.sleep(10)
+      yield* bus.publish(TestEvent, { value: 1 })
+      yield* bus.publish(TestEvent, { value: 2 })
+      yield* Deferred.await(receivedTwo).pipe(Effect.timeout("2 seconds"))
 
       expect(received).toEqual([1, 2])
 
-      unsub()
-      await Bun.sleep(10)
-      await Bus.publish(TestEvent, { value: 3 })
-      await Bun.sleep(10)
+      yield* Effect.sync(unsub)
+      yield* bus.publish(TestEvent, { value: 3 })
+      yield* Effect.sleep("10 millis")
 
       expect(received).toEqual([1, 2])
-    })
-  })
+    }),
+  )
 
-  test("subscribeAll receives events from multiple types", async () => {
-    await using tmp = await tmpdir()
-    const received: Array<{ type: string; value?: number }> = []
+  it.instance("subscribeAll receives events from multiple types", () =>
+    Effect.gen(function* () {
+      const bus = yield* Bus.Service
+      const received: Array<{ type: string; value?: number }> = []
+      const OtherEvent = BusEvent.define("test.other", Schema.Struct({ value: Schema.Number }))
+      const receivedTwo = yield* Deferred.make<void>()
 
-    const OtherEvent = BusEvent.define("test.other", Schema.Struct({ value: Schema.Number }))
-
-    await withInstance(tmp.path, async () => {
-      Bus.subscribeAll((evt) => {
+      yield* bus.subscribeAllCallback((evt) => {
         received.push({ type: evt.type, value: evt.properties.value })
+        if (received.length === 2) Deferred.doneUnsafe(receivedTwo, Effect.void)
       })
-      await Bun.sleep(10)
-      await Bus.publish(TestEvent, { value: 10 })
-      await Bus.publish(OtherEvent, { value: 20 })
-      await Bun.sleep(10)
-    })
+      yield* bus.publish(TestEvent, { value: 10 })
+      yield* bus.publish(OtherEvent, { value: 20 })
+      yield* Deferred.await(receivedTwo).pipe(Effect.timeout("2 seconds"))
 
-    expect(received).toEqual([
-      { type: "test.integration", value: 10 },
-      { type: "test.other", value: 20 },
-    ])
-  })
+      expect(received).toEqual([
+        { type: "test.integration", value: 10 },
+        { type: "test.other", value: 20 },
+      ])
+    }),
+  )
 
-  test("subscriber cleanup on instance disposal interrupts the stream", async () => {
-    await using tmp = await tmpdir()
-    const received: number[] = []
-    let disposed = false
+  it.live("subscriber cleanup on instance disposal interrupts the stream", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped()
+      const received: number[] = []
+      const seen = yield* Deferred.make<void>()
+      const disposed = yield* Deferred.make<void>()
 
-    await withInstance(tmp.path, async () => {
-      Bus.subscribeAll((evt) => {
-        if (evt.type === Bus.InstanceDisposed.type) {
-          disposed = true
-          return
-        }
-        received.push(evt.properties.value)
-      })
-      await Bun.sleep(10)
-      await Bus.publish(TestEvent, { value: 1 })
-      await Bun.sleep(10)
-    })
+      yield* Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        yield* bus.subscribeAllCallback((evt) => {
+          if (evt.type === Bus.InstanceDisposed.type) {
+            Deferred.doneUnsafe(disposed, Effect.void)
+            return
+          }
+          received.push(evt.properties.value)
+          Deferred.doneUnsafe(seen, Effect.void)
+        })
+        yield* bus.publish(TestEvent, { value: 1 })
+        yield* Deferred.await(seen).pipe(Effect.timeout("2 seconds"))
+      }).pipe(provideInstance(dir))
 
-    await disposeAllInstances()
-    await Bun.sleep(50)
+      yield* Effect.promise(() => disposeAllInstances())
+      yield* Deferred.await(disposed).pipe(Effect.timeout("2 seconds"))
 
-    expect(received).toEqual([1])
-    expect(disposed).toBe(true)
-  })
+      expect(received).toEqual([1])
+    }),
+  )
 })

packages/opencode/test/bus/bus.test.ts

@@ -1,220 +1,240 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Schema } from "effect"
+import { afterEach, describe, expect } from "bun:test"
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+import { Deferred, Effect, Layer, Schema } from "effect"
 import { Bus } from "../../src/bus"
 import { BusEvent } from "../../src/bus/bus-event"
-import { Instance } from "../../src/project/instance"
-import { WithInstance } from "../../src/project/with-instance"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
+import { disposeAllInstances, provideInstance, tmpdirScoped } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
 
 const TestEvent = {
   Ping: BusEvent.define("test.ping", Schema.Struct({ value: Schema.Number })),
   Pong: BusEvent.define("test.pong", Schema.Struct({ message: Schema.String })),
 }
 
-function withInstance(directory: string, fn: () => Promise<void>) {
-  return WithInstance.provide({ directory, fn })
-}
+const it = testEffect(Layer.mergeAll(Bus.layer, CrossSpawnSpawner.defaultLayer))
 
 describe("Bus", () => {
   afterEach(() => disposeAllInstances())
 
   describe("publish + subscribe", () => {
-    test("subscriber is live immediately after subscribe returns", async () => {
-      await using tmp = await tmpdir()
-      const received: number[] = []
+    it.instance("subscriber is live immediately after subscribe returns", () =>
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        const received: number[] = []
+        const done = yield* Deferred.make<void>()
 
-      await withInstance(tmp.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
+        yield* bus.subscribeCallback(TestEvent.Ping, (evt) => {
           received.push(evt.properties.value)
+          Deferred.doneUnsafe(done, Effect.void)
         })
-        await Bus.publish(TestEvent.Ping, { value: 42 })
-        await Bun.sleep(10)
-      })
+        yield* bus.publish(TestEvent.Ping, { value: 42 })
+        yield* Deferred.await(done).pipe(Effect.timeout("2 seconds"))
 
-      expect(received).toEqual([42])
-    })
+        expect(received).toEqual([42])
+      }),
+    )
 
-    test("subscriber receives matching events", async () => {
-      await using tmp = await tmpdir()
-      const received: number[] = []
+    it.instance("subscriber receives matching events", () =>
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        const received: number[] = []
+        const done = yield* Deferred.make<void>()
 
-      await withInstance(tmp.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
+        yield* bus.subscribeCallback(TestEvent.Ping, (evt) => {
           received.push(evt.properties.value)
+          if (received.length === 2) Deferred.doneUnsafe(done, Effect.void)
         })
-        // Give the subscriber fiber time to start consuming
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 42 })
-        await Bus.publish(TestEvent.Ping, { value: 99 })
-        // Give subscriber time to process
-        await Bun.sleep(10)
-      })
+        yield* bus.publish(TestEvent.Ping, { value: 42 })
+        yield* bus.publish(TestEvent.Ping, { value: 99 })
+        yield* Deferred.await(done).pipe(Effect.timeout("2 seconds"))
 
-      expect(received).toEqual([42, 99])
-    })
+        expect(received).toEqual([42, 99])
+      }),
+    )
 
-    test("subscriber does not receive events of other types", async () => {
-      await using tmp = await tmpdir()
-      const pings: number[] = []
+    it.instance("subscriber does not receive events of other types", () =>
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        const pings: number[] = []
+        const done = yield* Deferred.make<void>()
 
-      await withInstance(tmp.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
+        yield* bus.subscribeCallback(TestEvent.Ping, (evt) => {
           pings.push(evt.properties.value)
+          Deferred.doneUnsafe(done, Effect.void)
         })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Pong, { message: "hello" })
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-      })
+        yield* bus.publish(TestEvent.Pong, { message: "hello" })
+        yield* bus.publish(TestEvent.Ping, { value: 1 })
+        yield* Deferred.await(done).pipe(Effect.timeout("2 seconds"))
 
-      expect(pings).toEqual([1])
-    })
+        expect(pings).toEqual([1])
+      }),
+    )
 
-    test("publish with no subscribers does not throw", async () => {
-      await using tmp = await tmpdir()
-
-      await withInstance(tmp.path, async () => {
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-      })
-    })
+    it.instance("publish with no subscribers does not throw", () =>
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        yield* bus.publish(TestEvent.Ping, { value: 1 })
+      }),
+    )
   })
 
   describe("unsubscribe", () => {
-    test("unsubscribe stops delivery", async () => {
-      await using tmp = await tmpdir()
-      const received: number[] = []
+    it.instance("unsubscribe stops delivery", () =>
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        const received: number[] = []
+        const first = yield* Deferred.make<void>()
 
-      await withInstance(tmp.path, async () => {
-        const unsub = Bus.subscribe(TestEvent.Ping, (evt) => {
+        const unsub = yield* bus.subscribeCallback(TestEvent.Ping, (evt) => {
           received.push(evt.properties.value)
+          if (evt.properties.value === 1) Deferred.doneUnsafe(first, Effect.void)
         })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-        unsub()
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 2 })
-        await Bun.sleep(10)
-      })
+        yield* bus.publish(TestEvent.Ping, { value: 1 })
+        yield* Deferred.await(first).pipe(Effect.timeout("2 seconds"))
+        yield* Effect.sync(unsub)
+        yield* bus.publish(TestEvent.Ping, { value: 2 })
+        yield* Effect.sleep("10 millis")
 
-      expect(received).toEqual([1])
-    })
+        expect(received).toEqual([1])
+      }),
+    )
   })
 
   describe("subscribeAll", () => {
-    test("subscribeAll is live immediately after subscribe returns", async () => {
-      await using tmp = await tmpdir()
-      const received: string[] = []
+    it.instance("subscribeAll is live immediately after subscribe returns", () =>
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        const received: string[] = []
+        const done = yield* Deferred.make<void>()
 
-      await withInstance(tmp.path, async () => {
-        Bus.subscribeAll((evt) => {
+        yield* bus.subscribeAllCallback((evt) => {
           received.push(evt.type)
+          Deferred.doneUnsafe(done, Effect.void)
         })
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-      })
+        yield* bus.publish(TestEvent.Ping, { value: 1 })
+        yield* Deferred.await(done).pipe(Effect.timeout("2 seconds"))
 
-      expect(received).toEqual(["test.ping"])
-    })
+        expect(received).toEqual(["test.ping"])
+      }),
+    )
 
-    test("receives all event types", async () => {
-      await using tmp = await tmpdir()
-      const received: string[] = []
+    it.instance("receives all event types", () =>
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        const received: string[] = []
+        const done = yield* Deferred.make<void>()
 
-      await withInstance(tmp.path, async () => {
-        Bus.subscribeAll((evt) => {
+        yield* bus.subscribeAllCallback((evt) => {
           received.push(evt.type)
+          if (received.length === 2) Deferred.doneUnsafe(done, Effect.void)
         })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bus.publish(TestEvent.Pong, { message: "hi" })
-        await Bun.sleep(10)
-      })
+        yield* bus.publish(TestEvent.Ping, { value: 1 })
+        yield* bus.publish(TestEvent.Pong, { message: "hi" })
+        yield* Deferred.await(done).pipe(Effect.timeout("2 seconds"))
 
-      expect(received).toContain("test.ping")
-      expect(received).toContain("test.pong")
-    })
+        expect(received).toContain("test.ping")
+        expect(received).toContain("test.pong")
+      }),
+    )
   })
 
   describe("multiple subscribers", () => {
-    test("all subscribers for same event type are called", async () => {
-      await using tmp = await tmpdir()
-      const a: number[] = []
-      const b: number[] = []
+    it.instance("all subscribers for same event type are called", () =>
+      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>()
 
-      await withInstance(tmp.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
+        yield* bus.subscribeCallback(TestEvent.Ping, (evt) => {
           a.push(evt.properties.value)
+          Deferred.doneUnsafe(doneA, Effect.void)
         })
-        Bus.subscribe(TestEvent.Ping, (evt) => {
+        yield* bus.subscribeCallback(TestEvent.Ping, (evt) => {
           b.push(evt.properties.value)
+          Deferred.doneUnsafe(doneB, Effect.void)
         })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 7 })
-        await Bun.sleep(10)
-      })
+        yield* bus.publish(TestEvent.Ping, { value: 7 })
+        yield* Deferred.await(doneA).pipe(Effect.timeout("2 seconds"))
+        yield* Deferred.await(doneB).pipe(Effect.timeout("2 seconds"))
 
-      expect(a).toEqual([7])
-      expect(b).toEqual([7])
-    })
+        expect(a).toEqual([7])
+        expect(b).toEqual([7])
+      }),
+    )
   })
 
   describe("instance isolation", () => {
-    test("events in one directory do not reach subscribers in another", async () => {
-      await using tmpA = await tmpdir()
-      await using tmpB = await tmpdir()
-      const receivedA: number[] = []
-      const receivedB: number[] = []
+    it.live("events in one directory do not reach subscribers in another", () =>
+      Effect.gen(function* () {
+        const tmpA = yield* tmpdirScoped()
+        const tmpB = yield* tmpdirScoped()
+        const receivedA: number[] = []
+        const receivedB: number[] = []
+        const doneA = yield* Deferred.make<void>()
+        const doneB = yield* Deferred.make<void>()
 
-      await withInstance(tmpA.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
-          receivedA.push(evt.properties.value)
-        })
-        await Bun.sleep(10)
-      })
+        yield* Effect.gen(function* () {
+          const bus = yield* Bus.Service
+          yield* bus.subscribeCallback(TestEvent.Ping, (evt) => {
+            receivedA.push(evt.properties.value)
+            Deferred.doneUnsafe(doneA, Effect.void)
+          })
+        }).pipe(provideInstance(tmpA))
 
-      await withInstance(tmpB.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
-          receivedB.push(evt.properties.value)
-        })
-        await Bun.sleep(10)
-      })
+        yield* Effect.gen(function* () {
+          const bus = yield* Bus.Service
+          yield* bus.subscribeCallback(TestEvent.Ping, (evt) => {
+            receivedB.push(evt.properties.value)
+            Deferred.doneUnsafe(doneB, Effect.void)
+          })
+        }).pipe(provideInstance(tmpB))
 
-      await withInstance(tmpA.path, async () => {
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-      })
+        yield* Effect.gen(function* () {
+          const bus = yield* Bus.Service
+          yield* bus.publish(TestEvent.Ping, { value: 1 })
+        }).pipe(provideInstance(tmpA))
 
-      await withInstance(tmpB.path, async () => {
-        await Bus.publish(TestEvent.Ping, { value: 2 })
-        await Bun.sleep(10)
-      })
+        yield* Effect.gen(function* () {
+          const bus = yield* Bus.Service
+          yield* bus.publish(TestEvent.Ping, { value: 2 })
+        }).pipe(provideInstance(tmpB))
 
-      expect(receivedA).toEqual([1])
-      expect(receivedB).toEqual([2])
-    })
+        yield* Deferred.await(doneA).pipe(Effect.timeout("2 seconds"))
+        yield* Deferred.await(doneB).pipe(Effect.timeout("2 seconds"))
+
+        expect(receivedA).toEqual([1])
+        expect(receivedB).toEqual([2])
+      }),
+    )
   })
 
   describe("instance disposal", () => {
-    test("InstanceDisposed is delivered to wildcard subscribers before stream ends", async () => {
-      await using tmp = await tmpdir()
-      const received: string[] = []
+    it.live("InstanceDisposed is delivered to wildcard subscribers before stream ends", () =>
+      Effect.gen(function* () {
+        const tmp = yield* tmpdirScoped()
+        const received: string[] = []
+        const seen = yield* Deferred.make<void>()
+        const disposed = yield* Deferred.make<void>()
 
-      await withInstance(tmp.path, async () => {
-        Bus.subscribeAll((evt) => {
-          received.push(evt.type)
-        })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-      })
+        yield* Effect.gen(function* () {
+          const bus = yield* Bus.Service
+          yield* bus.subscribeAllCallback((evt) => {
+            received.push(evt.type)
+            if (evt.type === TestEvent.Ping.type) Deferred.doneUnsafe(seen, Effect.void)
+            if (evt.type === Bus.InstanceDisposed.type) Deferred.doneUnsafe(disposed, Effect.void)
+          })
+          yield* bus.publish(TestEvent.Ping, { value: 1 })
+          yield* Deferred.await(seen).pipe(Effect.timeout("2 seconds"))
+        }).pipe(provideInstance(tmp))
 
-      // disposeAllInstances triggers the finalizer which publishes InstanceDisposed
-      await disposeAllInstances()
-      await Bun.sleep(50)
+        yield* Effect.promise(disposeAllInstances)
+        yield* Deferred.await(disposed).pipe(Effect.timeout("2 seconds"))
 
-      expect(received).toContain("test.ping")
-      expect(received).toContain(Bus.InstanceDisposed.type)
-    })
+        expect(received).toContain("test.ping")
+        expect(received).toContain(Bus.InstanceDisposed.type)
+      }),
+    )
   })
 })

packages/opencode/test/cli/error.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import { AccountTransportError } from "../../src/account/schema"
 import { FormatError } from "../../src/cli/error"
+import { UI } from "../../src/cli/ui"
 
 describe("cli.error", () => {
   test("formats account transport errors clearly", () => {
@@ -15,4 +16,8 @@ describe("cli.error", () => {
     expect(formatted).toContain("This failed before the server returned an HTTP response.")
     expect(formatted).toContain("Check your network, proxy, or VPN configuration and try again.")
   })
+
+  test("formats cancelled UI errors as empty output", () => {
+    expect(FormatError(new UI.CancelledError())).toBe("")
+  })
 })

packages/opencode/test/effect/runner.test.ts

@@ -3,6 +3,11 @@ import { Deferred, Effect, Exit, Fiber, Latch, Ref, Scope } from "effect"
 import { Runner } from "@/effect/runner"
 import { it } from "../lib/effect"
 
+const waitForState = <A, E>(runner: Runner.Runner<A, E>, tag: Runner.State<A, E>["_tag"]) =>
+  Effect.gen(function* () {
+    while (runner.state._tag !== tag) yield* Effect.yieldNow
+  }).pipe(Effect.timeout("1 second"))
+
 describe("Runner", () => {
   // --- ensureRunning semantics ---
 
@@ -152,7 +157,7 @@ describe("Runner", () => {
       const s = yield* Scope.Scope
       const runner = Runner.make<string>(s, { onInterrupt: Effect.succeed("fallback") })
       const fiber = yield* runner.ensureRunning(Effect.never.pipe(Effect.as("never"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Running")
 
       yield* runner.cancel
 
@@ -169,9 +174,9 @@ describe("Runner", () => {
       const runner = Runner.make<string>(s, { onInterrupt: Effect.succeed("fallback") })
 
       const a = yield* runner.ensureRunning(Effect.never.pipe(Effect.as("x"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Running")
       const b = yield* runner.ensureRunning(Effect.succeed("y")).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* Effect.yieldNow
 
       yield* runner.cancel
 
@@ -189,7 +194,7 @@ describe("Runner", () => {
       const s = yield* Scope.Scope
       const runner = Runner.make<string>(s)
       const fiber = yield* runner.ensureRunning(Effect.never.pipe(Effect.as("x"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Running")
       yield* runner.cancel
       yield* Fiber.await(fiber)
 
@@ -215,7 +220,7 @@ describe("Runner", () => {
         )
 
         const a = yield* runner.ensureRunning(first).pipe(Effect.exit, Effect.forkChild)
-        yield* Effect.sleep("10 millis")
+        yield* waitForState(runner, "Running")
 
         const stop = yield* runner.cancel.pipe(Effect.forkChild)
         yield* Deferred.await(hit).pipe(Effect.timeout("250 millis"))
@@ -293,7 +298,7 @@ describe("Runner", () => {
       const gate = yield* Deferred.make<void>()
 
       const sh = yield* runner.startShell(Deferred.await(gate).pipe(Effect.as("first"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Shell")
 
       const exit = yield* runner.startShell(Effect.succeed("second")).pipe(Effect.exit)
       expect(Exit.isFailure(exit)).toBe(true)
@@ -314,7 +319,7 @@ describe("Runner", () => {
       })
 
       const sh = yield* runner.startShell(Effect.never.pipe(Effect.as("aborted"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Shell")
 
       const exit = yield* runner.startShell(Effect.succeed("second")).pipe(Effect.exit)
       expect(Exit.isFailure(exit)).toBe(true)
@@ -333,7 +338,7 @@ describe("Runner", () => {
       const gate = yield* Deferred.make<void>()
 
       const sh = yield* runner.startShell(Deferred.await(gate).pipe(Effect.as("ignored"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Shell")
 
       const stop = yield* runner.cancel.pipe(Effect.forkChild)
       const stopExit = yield* Fiber.await(stop).pipe(Effect.timeout("250 millis"))
@@ -380,11 +385,11 @@ describe("Runner", () => {
       const gate = yield* Deferred.make<void>()
 
       const sh = yield* runner.startShell(Deferred.await(gate).pipe(Effect.as("shell-result"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Shell")
       expect(runner.state._tag).toBe("Shell")
 
       const run = yield* runner.ensureRunning(Effect.succeed("run-result")).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "ShellThenRun")
       expect(runner.state._tag).toBe("ShellThenRun")
 
       yield* Deferred.succeed(gate, undefined)
@@ -406,7 +411,7 @@ describe("Runner", () => {
       const gate = yield* Deferred.make<void>()
 
       const sh = yield* runner.startShell(Deferred.await(gate).pipe(Effect.as("shell"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Shell")
 
       const work = Effect.gen(function* () {
         yield* Ref.update(calls, (n) => n + 1)
@@ -414,7 +419,7 @@ describe("Runner", () => {
       })
       const a = yield* runner.ensureRunning(work).pipe(Effect.forkChild)
       const b = yield* runner.ensureRunning(work).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "ShellThenRun")
 
       yield* Deferred.succeed(gate, undefined)
       yield* Fiber.await(sh)
@@ -433,10 +438,10 @@ describe("Runner", () => {
       const runner = Runner.make<string>(s)
 
       const sh = yield* runner.startShell(Effect.never.pipe(Effect.as("aborted"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Shell")
 
       const run = yield* runner.ensureRunning(Effect.succeed("y")).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "ShellThenRun")
       expect(runner.state._tag).toBe("ShellThenRun")
 
       yield* runner.cancel
@@ -472,7 +477,7 @@ describe("Runner", () => {
         onIdle: Ref.update(count, (n) => n + 1),
       })
       const fiber = yield* runner.ensureRunning(Effect.never.pipe(Effect.as("x"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Running")
       yield* runner.cancel
       yield* Fiber.await(fiber)
       expect(yield* Ref.get(count)).toBeGreaterThanOrEqual(1)
@@ -502,7 +507,7 @@ describe("Runner", () => {
       const gate = yield* Deferred.make<void>()
 
       const fiber = yield* runner.ensureRunning(Deferred.await(gate).pipe(Effect.as("ok"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Running")
       expect(runner.busy).toBe(true)
 
       yield* Deferred.succeed(gate, undefined)
@@ -519,7 +524,7 @@ describe("Runner", () => {
       const gate = yield* Deferred.make<void>()
 
       const fiber = yield* runner.startShell(Deferred.await(gate).pipe(Effect.as("ok"))).pipe(Effect.forkChild)
-      yield* Effect.sleep("10 millis")
+      yield* waitForState(runner, "Shell")
       expect(runner.busy).toBe(true)
 
       yield* Deferred.succeed(gate, undefined)

packages/opencode/test/file/fsmonitor.test.ts

@@ -3,67 +3,71 @@ import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import fs from "fs/promises"
 import path from "path"
-import { File } from "../../src/file"
-import { Instance } from "../../src/project/instance"
-import { WithInstance } from "../../src/project/with-instance"
-import { provideInstance, tmpdir } from "../fixture/fixture"
 
-const run = <A, E>(eff: Effect.Effect<A, E, File.Service>) =>
-  Effect.runPromise(provideInstance(Instance.directory)(eff.pipe(Effect.provide(File.defaultLayer))))
-const status = () => run(File.Service.use((svc) => svc.status()))
-const read = (file: string) => run(File.Service.use((svc) => svc.read(file)))
-
-const wintest = process.platform === "win32" ? test : test.skip
+const it =
+  process.platform === "win32"
+    ? (await import("../lib/effect")).testEffect((await import("../../src/file")).File.defaultLayer)
+    : undefined
 
 describe("file fsmonitor", () => {
-  wintest("status does not start fsmonitor for readonly git checks", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const target = path.join(tmp.path, "tracked.txt")
+  if (!it) {
+    test.skip("status does not start fsmonitor for readonly git checks", () => {})
+    test.skip("read does not start fsmonitor for git diffs", () => {})
+    return
+  }
 
-    await fs.writeFile(target, "base\n")
-    await $`git add tracked.txt`.cwd(tmp.path).quiet()
-    await $`git commit -m init`.cwd(tmp.path).quiet()
-    await $`git config core.fsmonitor true`.cwd(tmp.path).quiet()
-    await $`git fsmonitor--daemon stop`.cwd(tmp.path).quiet().nothrow()
-    await fs.writeFile(target, "next\n")
-    await fs.writeFile(path.join(tmp.path, "new.txt"), "new\n")
+  it.instance(
+    "status does not start fsmonitor for readonly git checks",
+    () =>
+      Effect.gen(function* () {
+        const { File } = yield* Effect.promise(() => import("../../src/file"))
+        const { TestInstance } = yield* Effect.promise(() => import("../fixture/fixture"))
+        const directory = (yield* TestInstance).directory
+        const target = path.join(directory, "tracked.txt")
 
-    const before = await $`git fsmonitor--daemon status`.cwd(tmp.path).quiet().nothrow()
-    expect(before.exitCode).not.toBe(0)
+        yield* Effect.promise(() => fs.writeFile(target, "base\n"))
+        yield* Effect.promise(() => $`git add tracked.txt`.cwd(directory).quiet())
+        yield* Effect.promise(() => $`git commit -m init`.cwd(directory).quiet())
+        yield* Effect.promise(() => $`git config core.fsmonitor true`.cwd(directory).quiet())
+        yield* Effect.promise(() => $`git fsmonitor--daemon stop`.cwd(directory).quiet().nothrow())
+        yield* Effect.promise(() => fs.writeFile(target, "next\n"))
+        yield* Effect.promise(() => fs.writeFile(path.join(directory, "new.txt"), "new\n"))
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await status()
-      },
-    })
+        const before = yield* Effect.promise(() => $`git fsmonitor--daemon status`.cwd(directory).quiet().nothrow())
+        expect(before.exitCode).not.toBe(0)
 
-    const after = await $`git fsmonitor--daemon status`.cwd(tmp.path).quiet().nothrow()
-    expect(after.exitCode).not.toBe(0)
-  })
+        yield* File.Service.use((svc) => svc.status())
 
-  wintest("read does not start fsmonitor for git diffs", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const target = path.join(tmp.path, "tracked.txt")
+        const after = yield* Effect.promise(() => $`git fsmonitor--daemon status`.cwd(directory).quiet().nothrow())
+        expect(after.exitCode).not.toBe(0)
+      }),
+    { git: true },
+  )
 
-    await fs.writeFile(target, "base\n")
-    await $`git add tracked.txt`.cwd(tmp.path).quiet()
-    await $`git commit -m init`.cwd(tmp.path).quiet()
-    await $`git config core.fsmonitor true`.cwd(tmp.path).quiet()
-    await $`git fsmonitor--daemon stop`.cwd(tmp.path).quiet().nothrow()
-    await fs.writeFile(target, "next\n")
+  it.instance(
+    "read does not start fsmonitor for git diffs",
+    () =>
+      Effect.gen(function* () {
+        const { File } = yield* Effect.promise(() => import("../../src/file"))
+        const { TestInstance } = yield* Effect.promise(() => import("../fixture/fixture"))
+        const directory = (yield* TestInstance).directory
+        const target = path.join(directory, "tracked.txt")
 
-    const before = await $`git fsmonitor--daemon status`.cwd(tmp.path).quiet().nothrow()
-    expect(before.exitCode).not.toBe(0)
+        yield* Effect.promise(() => fs.writeFile(target, "base\n"))
+        yield* Effect.promise(() => $`git add tracked.txt`.cwd(directory).quiet())
+        yield* Effect.promise(() => $`git commit -m init`.cwd(directory).quiet())
+        yield* Effect.promise(() => $`git config core.fsmonitor true`.cwd(directory).quiet())
+        yield* Effect.promise(() => $`git fsmonitor--daemon stop`.cwd(directory).quiet().nothrow())
+        yield* Effect.promise(() => fs.writeFile(target, "next\n"))
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await read("tracked.txt")
-      },
-    })
+        const before = yield* Effect.promise(() => $`git fsmonitor--daemon status`.cwd(directory).quiet().nothrow())
+        expect(before.exitCode).not.toBe(0)
 
-    const after = await $`git fsmonitor--daemon status`.cwd(tmp.path).quiet().nothrow()
-    expect(after.exitCode).not.toBe(0)
-  })
+        yield* File.Service.use((svc) => svc.read("tracked.txt"))
+
+        const after = yield* Effect.promise(() => $`git fsmonitor--daemon status`.cwd(directory).quiet().nothrow())
+        expect(after.exitCode).not.toBe(0)
+      }),
+    { git: true },
+  )
 })

packages/opencode/test/file/path-traversal.test.ts

@@ -1,42 +1,55 @@
-import { test, expect, describe } from "bun:test"
-import { Effect } from "effect"
+import { expect, describe } from "bun:test"
+import { Cause, Effect, Exit } from "effect"
 import path from "path"
 import fs from "fs/promises"
 import { Filesystem } from "@/util/filesystem"
 import { File } from "../../src/file"
-import { Instance } from "../../src/project/instance"
-import { WithInstance } from "../../src/project/with-instance"
+import { InstanceState } from "../../src/effect/instance-state"
 import { containsPath } from "../../src/project/instance-context"
-import { provideInstance, tmpdir } from "../fixture/fixture"
+import { TestInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
 
-const run = <A, E>(eff: Effect.Effect<A, E, File.Service>) =>
-  Effect.runPromise(provideInstance(Instance.directory)(eff.pipe(Effect.provide(File.defaultLayer))))
-const read = (file: string) => run(File.Service.use((svc) => svc.read(file)))
-const list = (dir?: string) => run(File.Service.use((svc) => svc.list(dir)))
+const it = testEffect(File.defaultLayer)
+const read = (file: string) => File.Service.use((svc) => svc.read(file))
+const list = (dir?: string) => File.Service.use((svc) => svc.list(dir))
+const expectAccessDenied = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  Effect.gen(function* () {
+    const exit = yield* effect.pipe(Effect.exit)
+    if (Exit.isSuccess(exit)) throw new Error("expected access denied")
+    expect(Cause.squash(exit.cause)).toHaveProperty("message", "Access denied: path escapes project directory")
+  })
 
 describe("Filesystem.contains", () => {
-  test("allows paths within project", () => {
-    expect(Filesystem.contains("/project", "/project/src")).toBe(true)
-    expect(Filesystem.contains("/project", "/project/src/file.ts")).toBe(true)
-    expect(Filesystem.contains("/project", "/project")).toBe(true)
-  })
+  it.effect("allows paths within project", () =>
+    Effect.sync(() => {
+      expect(Filesystem.contains("/project", "/project/src")).toBe(true)
+      expect(Filesystem.contains("/project", "/project/src/file.ts")).toBe(true)
+      expect(Filesystem.contains("/project", "/project")).toBe(true)
+    }),
+  )
 
-  test("blocks ../ traversal", () => {
-    expect(Filesystem.contains("/project", "/project/../etc")).toBe(false)
-    expect(Filesystem.contains("/project", "/project/src/../../etc")).toBe(false)
-    expect(Filesystem.contains("/project", "/etc/passwd")).toBe(false)
-  })
+  it.effect("blocks ../ traversal", () =>
+    Effect.sync(() => {
+      expect(Filesystem.contains("/project", "/project/../etc")).toBe(false)
+      expect(Filesystem.contains("/project", "/project/src/../../etc")).toBe(false)
+      expect(Filesystem.contains("/project", "/etc/passwd")).toBe(false)
+    }),
+  )
 
-  test("blocks absolute paths outside project", () => {
-    expect(Filesystem.contains("/project", "/etc/passwd")).toBe(false)
-    expect(Filesystem.contains("/project", "/tmp/file")).toBe(false)
-    expect(Filesystem.contains("/home/user/project", "/home/user/other")).toBe(false)
-  })
+  it.effect("blocks absolute paths outside project", () =>
+    Effect.sync(() => {
+      expect(Filesystem.contains("/project", "/etc/passwd")).toBe(false)
+      expect(Filesystem.contains("/project", "/tmp/file")).toBe(false)
+      expect(Filesystem.contains("/home/user/project", "/home/user/other")).toBe(false)
+    }),
+  )
 
-  test("handles prefix collision edge cases", () => {
-    expect(Filesystem.contains("/project", "/project-other/file")).toBe(false)
-    expect(Filesystem.contains("/project", "/projectfile")).toBe(false)
-  })
+  it.effect("handles prefix collision edge cases", () =>
+    Effect.sync(() => {
+      expect(Filesystem.contains("/project", "/project-other/file")).toBe(false)
+      expect(Filesystem.contains("/project", "/projectfile")).toBe(false)
+    }),
+  )
 })
 
 /*
@@ -49,158 +62,124 @@ describe("Filesystem.contains", () => {
  * This is a SEPARATE code path from ReadTool, which has its own checks.
  */
 describe("File.read path traversal protection", () => {
-  test("rejects ../ traversal attempting to read /etc/passwd", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "allowed.txt"), "allowed content")
-      },
-    })
+  it.instance("rejects ../ traversal attempting to read /etc/passwd", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      yield* Effect.promise(() => Bun.write(path.join(test.directory, "allowed.txt"), "allowed content"))
+      yield* expectAccessDenied(read("../../../etc/passwd"))
+    }),
+  )
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await expect(read("../../../etc/passwd")).rejects.toThrow("Access denied: path escapes project directory")
-      },
-    })
-  })
+  it.instance("rejects deeply nested traversal", () =>
+    Effect.gen(function* () {
+      yield* expectAccessDenied(read("src/nested/../../../../../../../etc/passwd"))
+    }),
+  )
 
-  test("rejects deeply nested traversal", async () => {
-    await using tmp = await tmpdir()
+  it.instance("allows valid paths within project", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      yield* Effect.promise(() => Bun.write(path.join(test.directory, "valid.txt"), "valid content"))
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await expect(read("src/nested/../../../../../../../etc/passwd")).rejects.toThrow(
-          "Access denied: path escapes project directory",
-        )
-      },
-    })
-  })
-
-  test("allows valid paths within project", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "valid.txt"), "valid content")
-      },
-    })
-
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const result = await read("valid.txt")
-        expect(result.content).toBe("valid content")
-      },
-    })
-  })
+      const result = yield* read("valid.txt")
+      expect(result.content).toBe("valid content")
+    }),
+  )
 })
 
 describe("File.list path traversal protection", () => {
-  test("rejects ../ traversal attempting to list /etc", async () => {
-    await using tmp = await tmpdir()
+  it.instance("rejects ../ traversal attempting to list /etc", () =>
+    Effect.gen(function* () {
+      yield* expectAccessDenied(list("../../../etc"))
+    }),
+  )
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await expect(list("../../../etc")).rejects.toThrow("Access denied: path escapes project directory")
-      },
-    })
-  })
+  it.instance("allows valid subdirectory listing", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      yield* Effect.promise(() => Bun.write(path.join(test.directory, "subdir", "file.txt"), "content"))
 
-  test("allows valid subdirectory listing", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "subdir", "file.txt"), "content")
-      },
-    })
-
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const result = await list("subdir")
-        expect(Array.isArray(result)).toBe(true)
-      },
-    })
-  })
+      const result = yield* list("subdir")
+      expect(Array.isArray(result)).toBe(true)
+    }),
+  )
 })
 
 describe("containsPath", () => {
-  test("returns true for path inside directory", async () => {
-    await using tmp = await tmpdir({ git: true })
+  it.instance(
+    "returns true for path inside directory",
+    () =>
+      Effect.gen(function* () {
+        const test = yield* TestInstance
+        const ctx = yield* InstanceState.context
+        expect(containsPath(path.join(test.directory, "foo.txt"), ctx)).toBe(true)
+        expect(containsPath(path.join(test.directory, "src", "file.ts"), ctx)).toBe(true)
+      }),
+    { git: true },
+  )
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: () => {
-        expect(containsPath(path.join(tmp.path, "foo.txt"), Instance.current)).toBe(true)
-        expect(containsPath(path.join(tmp.path, "src", "file.ts"), Instance.current)).toBe(true)
-      },
-    })
-  })
+  it.instance(
+    "returns true for path inside worktree but outside directory (monorepo subdirectory scenario)",
+    () =>
+      Effect.gen(function* () {
+        const test = yield* TestInstance
+        const subdir = path.join(test.directory, "packages", "lib")
+        yield* Effect.promise(() => fs.mkdir(subdir, { recursive: true }))
+        const ctx = { ...(yield* InstanceState.context), directory: subdir }
 
-  test("returns true for path inside worktree but outside directory (monorepo subdirectory scenario)", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const subdir = path.join(tmp.path, "packages", "lib")
-    await fs.mkdir(subdir, { recursive: true })
-
-    await WithInstance.provide({
-      directory: subdir,
-      fn: () => {
         // .opencode at worktree root, but we're running from packages/lib
-        expect(containsPath(path.join(tmp.path, ".opencode", "state"), Instance.current)).toBe(true)
+        expect(containsPath(path.join(test.directory, ".opencode", "state"), ctx)).toBe(true)
         // sibling package should also be accessible
-        expect(containsPath(path.join(tmp.path, "packages", "other", "file.ts"), Instance.current)).toBe(true)
+        expect(containsPath(path.join(test.directory, "packages", "other", "file.ts"), ctx)).toBe(true)
         // worktree root itself
-        expect(containsPath(tmp.path, Instance.current)).toBe(true)
-      },
-    })
-  })
+        expect(containsPath(test.directory, ctx)).toBe(true)
+      }),
+    { git: true },
+  )
 
-  test("returns false for path outside both directory and worktree", async () => {
-    await using tmp = await tmpdir({ git: true })
+  it.instance(
+    "returns false for path outside both directory and worktree",
+    () =>
+      Effect.gen(function* () {
+        const ctx = yield* InstanceState.context
+        expect(containsPath("/etc/passwd", ctx)).toBe(false)
+        expect(containsPath("/tmp/other-project", ctx)).toBe(false)
+      }),
+    { git: true },
+  )
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: () => {
-        expect(containsPath("/etc/passwd", Instance.current)).toBe(false)
-        expect(containsPath("/tmp/other-project", Instance.current)).toBe(false)
-      },
-    })
-  })
+  it.instance(
+    "returns false for path with .. escaping worktree",
+    () =>
+      Effect.gen(function* () {
+        const test = yield* TestInstance
+        const ctx = yield* InstanceState.context
+        expect(containsPath(path.join(test.directory, "..", "escape.txt"), ctx)).toBe(false)
+      }),
+    { git: true },
+  )
 
-  test("returns false for path with .. escaping worktree", async () => {
-    await using tmp = await tmpdir({ git: true })
+  it.instance(
+    "handles directory === worktree (running from repo root)",
+    () =>
+      Effect.gen(function* () {
+        const test = yield* TestInstance
+        const ctx = yield* InstanceState.context
+        expect(ctx.directory).toBe(ctx.worktree)
+        expect(containsPath(path.join(test.directory, "file.txt"), ctx)).toBe(true)
+        expect(containsPath("/etc/passwd", ctx)).toBe(false)
+      }),
+    { git: true },
+  )
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: () => {
-        expect(containsPath(path.join(tmp.path, "..", "escape.txt"), Instance.current)).toBe(false)
-      },
-    })
-  })
-
-  test("handles directory === worktree (running from repo root)", async () => {
-    await using tmp = await tmpdir({ git: true })
-
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: () => {
-        expect(Instance.directory).toBe(Instance.worktree)
-        expect(containsPath(path.join(tmp.path, "file.txt"), Instance.current)).toBe(true)
-        expect(containsPath("/etc/passwd", Instance.current)).toBe(false)
-      },
-    })
-  })
-
-  test("non-git project does not allow arbitrary paths via worktree='/'", async () => {
-    await using tmp = await tmpdir() // no git: true
-
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: () => {
-        // worktree is "/" for non-git projects, but containsPath should NOT allow all paths
-        expect(containsPath(path.join(tmp.path, "file.txt"), Instance.current)).toBe(true)
-        expect(containsPath("/etc/passwd", Instance.current)).toBe(false)
-        expect(containsPath("/tmp/other", Instance.current)).toBe(false)
-      },
-    })
-  })
+  it.instance("non-git project does not allow arbitrary paths via worktree='/'", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const ctx = yield* InstanceState.context
+      // worktree is "/" for non-git projects, but containsPath should NOT allow all paths
+      expect(containsPath(path.join(test.directory, "file.txt"), ctx)).toBe(true)
+      expect(containsPath("/etc/passwd", ctx)).toBe(false)
+      expect(containsPath("/tmp/other", ctx)).toBe(false)
+    }),
+  )
 })

packages/opencode/test/file/ripgrep.test.ts

@@ -1,214 +1,220 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import * as Stream from "effect/Stream"
 import fs from "fs/promises"
+import os from "os"
 import path from "path"
-import { tmpdir } from "../fixture/fixture"
 import { Ripgrep } from "../../src/file/ripgrep"
+import { testEffect } from "../lib/effect"
 
-const run = <A>(effect: Effect.Effect<A, unknown, Ripgrep.Service>) =>
-  effect.pipe(Effect.provide(Ripgrep.defaultLayer), Effect.runPromise)
+const it = testEffect(Ripgrep.defaultLayer)
+
+const tmpdir = (init?: (dir: string) => Effect.Effect<void>) =>
+  Effect.acquireRelease(
+    Effect.promise(async () => fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(), "opencode-test-")))),
+    (dir) =>
+      Effect.promise(() =>
+        fs.rm(dir, {
+          recursive: true,
+          force: true,
+          maxRetries: 5,
+          retryDelay: 100,
+        }),
+      ).pipe(Effect.ignore),
+  ).pipe(Effect.tap((dir) => init?.(dir) ?? Effect.void))
+
+const write = (file: string, data: string) => Effect.promise(() => Bun.write(file, data))
+const mkdir = (dir: string) => Effect.promise(() => fs.mkdir(dir, { recursive: true }))
+const collectFiles = (input: Ripgrep.FilesInput) =>
+  Ripgrep.Service.use((rg) =>
+    rg.files(input).pipe(
+      Stream.runCollect,
+      Effect.map((c) => [...c]),
+    ),
+  )
+
+const withRipgrepConfig = <A, E, R>(value: string, effect: Effect.Effect<A, E, R>) =>
+  Effect.acquireUseRelease(
+    Effect.sync(() => {
+      const prev = process.env["RIPGREP_CONFIG_PATH"]
+      process.env["RIPGREP_CONFIG_PATH"] = value
+      return prev
+    }),
+    () => effect,
+    (prev) =>
+      Effect.sync(() => {
+        if (prev === undefined) delete process.env["RIPGREP_CONFIG_PATH"]
+        else process.env["RIPGREP_CONFIG_PATH"] = prev
+      }),
+  )
 
 describe("file.ripgrep", () => {
-  test("defaults to include hidden", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "visible.txt"), "hello")
-        await fs.mkdir(path.join(dir, ".opencode"), { recursive: true })
-        await Bun.write(path.join(dir, ".opencode", "thing.json"), "{}")
-      },
-    })
+  it.live("defaults to include hidden", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdir((dir) =>
+        Effect.gen(function* () {
+          yield* write(path.join(dir, "visible.txt"), "hello")
+          yield* mkdir(path.join(dir, ".opencode"))
+          yield* write(path.join(dir, ".opencode", "thing.json"), "{}")
+        }),
+      )
 
-    const files = await run(
-      Ripgrep.Service.use((rg) =>
-        rg.files({ cwd: tmp.path }).pipe(
-          Stream.runCollect,
-          Effect.map((c) => [...c]),
-        ),
-      ),
-    )
-    expect(files.includes("visible.txt")).toBe(true)
-    expect(files.includes(path.join(".opencode", "thing.json"))).toBe(true)
-  })
+      const files = yield* collectFiles({ cwd: dir })
+      expect(files.includes("visible.txt")).toBe(true)
+      expect(files.includes(path.join(".opencode", "thing.json"))).toBe(true)
+    }),
+  )
 
-  test("hidden false excludes hidden", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "visible.txt"), "hello")
-        await fs.mkdir(path.join(dir, ".opencode"), { recursive: true })
-        await Bun.write(path.join(dir, ".opencode", "thing.json"), "{}")
-      },
-    })
+  it.live("hidden false excludes hidden", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdir((dir) =>
+        Effect.gen(function* () {
+          yield* write(path.join(dir, "visible.txt"), "hello")
+          yield* mkdir(path.join(dir, ".opencode"))
+          yield* write(path.join(dir, ".opencode", "thing.json"), "{}")
+        }),
+      )
 
-    const files = await run(
-      Ripgrep.Service.use((rg) =>
-        rg.files({ cwd: tmp.path, hidden: false }).pipe(
-          Stream.runCollect,
-          Effect.map((c) => [...c]),
-        ),
-      ),
-    )
-    expect(files.includes("visible.txt")).toBe(true)
-    expect(files.includes(path.join(".opencode", "thing.json"))).toBe(false)
-  })
+      const files = yield* collectFiles({ cwd: dir, hidden: false })
+      expect(files.includes("visible.txt")).toBe(true)
+      expect(files.includes(path.join(".opencode", "thing.json"))).toBe(false)
+    }),
+  )
 
-  test("search returns empty when nothing matches", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "match.ts"), "const value = 'other'\n")
-      },
-    })
+  it.live("search returns empty when nothing matches", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdir((dir) => write(path.join(dir, "match.ts"), "const value = 'other'\n"))
 
-    const result = await run(Ripgrep.Service.use((rg) => rg.search({ cwd: tmp.path, pattern: "needle" })))
-    expect(result.partial).toBe(false)
-    expect(result.items).toEqual([])
-  })
+      const result = yield* Ripgrep.Service.use((rg) => rg.search({ cwd: dir, pattern: "needle" }))
+      expect(result.partial).toBe(false)
+      expect(result.items).toEqual([])
+    }),
+  )
 
-  test("search returns match metadata with normalized path", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await fs.mkdir(path.join(dir, "src"), { recursive: true })
-        await Bun.write(path.join(dir, "src", "match.ts"), "const needle = 1\n")
-      },
-    })
+  it.live("search returns match metadata with normalized path", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdir((dir) =>
+        Effect.gen(function* () {
+          yield* mkdir(path.join(dir, "src"))
+          yield* write(path.join(dir, "src", "match.ts"), "const needle = 1\n")
+        }),
+      )
 
-    const result = await run(Ripgrep.Service.use((rg) => rg.search({ cwd: tmp.path, pattern: "needle" })))
-    expect(result.partial).toBe(false)
-    expect(result.items).toHaveLength(1)
-    expect(result.items[0]?.path.text).toBe(path.join("src", "match.ts"))
-    expect(result.items[0]?.line_number).toBe(1)
-    expect(result.items[0]?.lines.text).toContain("needle")
-  })
-
-  test("search returns matched rows with glob filter", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "match.ts"), "const value = 'needle'\n")
-        await Bun.write(path.join(dir, "skip.txt"), "const value = 'other'\n")
-      },
-    })
-
-    const result = await run(
-      Ripgrep.Service.use((rg) => rg.search({ cwd: tmp.path, pattern: "needle", glob: ["*.ts"] })),
-    )
-    expect(result.partial).toBe(false)
-    expect(result.items).toHaveLength(1)
-    expect(result.items[0]?.path.text).toContain("match.ts")
-    expect(result.items[0]?.lines.text).toContain("needle")
-  })
-
-  test("search supports explicit file targets", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "match.ts"), "const value = 'needle'\n")
-        await Bun.write(path.join(dir, "skip.ts"), "const value = 'needle'\n")
-      },
-    })
-
-    const file = path.join(tmp.path, "match.ts")
-    const result = await run(Ripgrep.Service.use((rg) => rg.search({ cwd: tmp.path, pattern: "needle", file: [file] })))
-    expect(result.partial).toBe(false)
-    expect(result.items).toHaveLength(1)
-    expect(result.items[0]?.path.text).toBe(file)
-  })
-
-  test("files returns empty when glob matches no files", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await fs.mkdir(path.join(dir, "packages", "console"), { recursive: true })
-        await Bun.write(path.join(dir, "packages", "console", "package.json"), "{}")
-      },
-    })
-
-    const files = await run(
-      Ripgrep.Service.use((rg) =>
-        rg.files({ cwd: tmp.path, glob: ["packages/*"] }).pipe(
-          Stream.runCollect,
-          Effect.map((c) => [...c]),
-        ),
-      ),
-    )
-    expect(files).toEqual([])
-  })
-
-  test("files returns stream of filenames", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "a.txt"), "hello")
-        await Bun.write(path.join(dir, "b.txt"), "world")
-      },
-    })
-
-    const files = await run(
-      Ripgrep.Service.use((rg) =>
-        rg.files({ cwd: tmp.path }).pipe(
-          Stream.runCollect,
-          Effect.map((c) => [...c].sort()),
-        ),
-      ),
-    )
-    expect(files).toEqual(["a.txt", "b.txt"])
-  })
-
-  test("files respects glob filter", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "keep.ts"), "yes")
-        await Bun.write(path.join(dir, "skip.txt"), "no")
-      },
-    })
-
-    const files = await run(
-      Ripgrep.Service.use((rg) =>
-        rg.files({ cwd: tmp.path, glob: ["*.ts"] }).pipe(
-          Stream.runCollect,
-          Effect.map((c) => [...c]),
-        ),
-      ),
-    )
-    expect(files).toEqual(["keep.ts"])
-  })
-
-  test("files dies on nonexistent directory", async () => {
-    const exit = await Ripgrep.Service.use((rg) =>
-      rg.files({ cwd: "/tmp/nonexistent-dir-12345" }).pipe(Stream.runCollect),
-    ).pipe(Effect.provide(Ripgrep.defaultLayer), Effect.runPromiseExit)
-    expect(exit._tag).toBe("Failure")
-  })
-
-  test("ignores RIPGREP_CONFIG_PATH in direct mode", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "match.ts"), "const needle = 1\n")
-      },
-    })
-
-    const prev = process.env["RIPGREP_CONFIG_PATH"]
-    process.env["RIPGREP_CONFIG_PATH"] = path.join(tmp.path, "missing-ripgreprc")
-    try {
-      const result = await run(Ripgrep.Service.use((rg) => rg.search({ cwd: tmp.path, pattern: "needle" })))
+      const result = yield* Ripgrep.Service.use((rg) => rg.search({ cwd: dir, pattern: "needle" }))
+      expect(result.partial).toBe(false)
       expect(result.items).toHaveLength(1)
-    } finally {
-      if (prev === undefined) delete process.env["RIPGREP_CONFIG_PATH"]
-      else process.env["RIPGREP_CONFIG_PATH"] = prev
-    }
-  })
+      expect(result.items[0]?.path.text).toBe(path.join("src", "match.ts"))
+      expect(result.items[0]?.line_number).toBe(1)
+      expect(result.items[0]?.lines.text).toContain("needle")
+    }),
+  )
 
-  test("ignores RIPGREP_CONFIG_PATH in worker mode", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "match.ts"), "const needle = 1\n")
-      },
-    })
+  it.live("search returns matched rows with glob filter", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdir((dir) =>
+        Effect.gen(function* () {
+          yield* write(path.join(dir, "match.ts"), "const value = 'needle'\n")
+          yield* write(path.join(dir, "skip.txt"), "const value = 'other'\n")
+        }),
+      )
 
-    const prev = process.env["RIPGREP_CONFIG_PATH"]
-    process.env["RIPGREP_CONFIG_PATH"] = path.join(tmp.path, "missing-ripgreprc")
-    try {
-      const result = await run(Ripgrep.Service.use((rg) => rg.search({ cwd: tmp.path, pattern: "needle" })))
+      const result = yield* Ripgrep.Service.use((rg) => rg.search({ cwd: dir, pattern: "needle", glob: ["*.ts"] }))
+      expect(result.partial).toBe(false)
       expect(result.items).toHaveLength(1)
-    } finally {
-      if (prev === undefined) delete process.env["RIPGREP_CONFIG_PATH"]
-      else process.env["RIPGREP_CONFIG_PATH"] = prev
-    }
-  })
+      expect(result.items[0]?.path.text).toContain("match.ts")
+      expect(result.items[0]?.lines.text).toContain("needle")
+    }),
+  )
+
+  it.live("search supports explicit file targets", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdir((dir) =>
+        Effect.gen(function* () {
+          yield* write(path.join(dir, "match.ts"), "const value = 'needle'\n")
+          yield* write(path.join(dir, "skip.ts"), "const value = 'needle'\n")
+        }),
+      )
+
+      const file = path.join(dir, "match.ts")
+      const result = yield* Ripgrep.Service.use((rg) => rg.search({ cwd: dir, pattern: "needle", file: [file] }))
+      expect(result.partial).toBe(false)
+      expect(result.items).toHaveLength(1)
+      expect(result.items[0]?.path.text).toBe(file)
+    }),
+  )
+
+  it.live("files returns empty when glob matches no files", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdir((dir) =>
+        Effect.gen(function* () {
+          yield* mkdir(path.join(dir, "packages", "console"))
+          yield* write(path.join(dir, "packages", "console", "package.json"), "{}")
+        }),
+      )
+
+      const files = yield* collectFiles({ cwd: dir, glob: ["packages/*"] })
+      expect(files).toEqual([])
+    }),
+  )
+
+  it.live("files returns stream of filenames", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdir((dir) =>
+        Effect.gen(function* () {
+          yield* write(path.join(dir, "a.txt"), "hello")
+          yield* write(path.join(dir, "b.txt"), "world")
+        }),
+      )
+
+      const files = yield* collectFiles({ cwd: dir }).pipe(Effect.map((files) => files.sort()))
+      expect(files).toEqual(["a.txt", "b.txt"])
+    }),
+  )
+
+  it.live("files respects glob filter", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdir((dir) =>
+        Effect.gen(function* () {
+          yield* write(path.join(dir, "keep.ts"), "yes")
+          yield* write(path.join(dir, "skip.txt"), "no")
+        }),
+      )
+
+      const files = yield* collectFiles({ cwd: dir, glob: ["*.ts"] })
+      expect(files).toEqual(["keep.ts"])
+    }),
+  )
+
+  it.live("files dies on nonexistent directory", () =>
+    Effect.gen(function* () {
+      const exit = yield* Ripgrep.Service.use((rg) =>
+        rg.files({ cwd: "/tmp/nonexistent-dir-12345" }).pipe(Stream.runCollect),
+      ).pipe(Effect.exit)
+      expect(exit._tag).toBe("Failure")
+    }),
+  )
+
+  it.live("ignores RIPGREP_CONFIG_PATH in direct mode", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdir((dir) => write(path.join(dir, "match.ts"), "const needle = 1\n"))
+
+      const result = yield* withRipgrepConfig(
+        path.join(dir, "missing-ripgreprc"),
+        Ripgrep.Service.use((rg) => rg.search({ cwd: dir, pattern: "needle" })),
+      )
+      expect(result.items).toHaveLength(1)
+    }),
+  )
+
+  it.live("ignores RIPGREP_CONFIG_PATH in worker mode", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdir((dir) => write(path.join(dir, "match.ts"), "const needle = 1\n"))
+
+      const result = yield* withRipgrepConfig(
+        path.join(dir, "missing-ripgreprc"),
+        Ripgrep.Service.use((rg) => rg.search({ cwd: dir, pattern: "needle" })),
+      )
+      expect(result.items).toHaveLength(1)
+    }),
+  )
 })

packages/opencode/test/fixture/fixture.ts

@@ -135,7 +135,7 @@ export function tmpdirScoped(options?: { git?: boolean; config?: Partial<Config.
       yield* git("config", "commit.gpgsign", "false")
       yield* git("config", "user.email", "test@opencode.test")
       yield* git("config", "user.name", "Test")
-      yield* git("commit", "--allow-empty", "-m", "root commit")
+      yield* git("commit", "--allow-empty", "-m", `root commit ${dir}`)
     }
 
     if (options?.config) {

packages/opencode/test/git/git.test.ts

@@ -1,71 +1,70 @@
 import { $ } from "bun"
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
-import { ManagedRuntime } from "effect"
+import { Effect } from "effect"
 import { Git } from "../../src/git"
 import { tmpdir } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
 
 const weird = process.platform === "win32" ? "space file.txt" : "tab\tfile.txt"
+const it = testEffect(Git.defaultLayer)
 
-async function withGit<T>(body: (rt: ManagedRuntime.ManagedRuntime<Git.Service, never>) => Promise<T>) {
-  const rt = ManagedRuntime.make(Git.defaultLayer)
-  try {
-    return await body(rt)
-  } finally {
-    await rt.dispose()
-  }
-}
+const scopedTmpdir = (options?: Parameters<typeof tmpdir>[0]) =>
+  Effect.acquireRelease(
+    Effect.promise(() => tmpdir(options)),
+    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+  )
 
 describe("Git", () => {
-  test("branch() returns current branch name", async () => {
-    await using tmp = await tmpdir({ git: true })
-
-    await withGit(async (rt) => {
-      const branch = await rt.runPromise(Git.Service.use((git) => git.branch(tmp.path)))
+  it.live("branch() returns current branch name", () =>
+    Effect.gen(function* () {
+      const tmp = yield* scopedTmpdir({ git: true })
+      const git = yield* Git.Service
+      const branch = yield* git.branch(tmp.path)
       expect(branch).toBeDefined()
       expect(typeof branch).toBe("string")
-    })
-  })
+    }),
+  )
 
-  test("branch() returns undefined for non-git directories", async () => {
-    await using tmp = await tmpdir()
-
-    await withGit(async (rt) => {
-      const branch = await rt.runPromise(Git.Service.use((git) => git.branch(tmp.path)))
+  it.live("branch() returns undefined for non-git directories", () =>
+    Effect.gen(function* () {
+      const tmp = yield* scopedTmpdir()
+      const git = yield* Git.Service
+      const branch = yield* git.branch(tmp.path)
       expect(branch).toBeUndefined()
-    })
-  })
+    }),
+  )
 
-  test("branch() returns undefined for detached HEAD", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const hash = (await $`git rev-parse HEAD`.cwd(tmp.path).quiet().text()).trim()
-    await $`git checkout --detach ${hash}`.cwd(tmp.path).quiet()
-
-    await withGit(async (rt) => {
-      const branch = await rt.runPromise(Git.Service.use((git) => git.branch(tmp.path)))
+  it.live("branch() returns undefined for detached HEAD", () =>
+    Effect.gen(function* () {
+      const tmp = yield* scopedTmpdir({ git: true })
+      const hash = (yield* Effect.promise(() => $`git rev-parse HEAD`.cwd(tmp.path).quiet().text())).trim()
+      yield* Effect.promise(() => $`git checkout --detach ${hash}`.cwd(tmp.path).quiet())
+      const git = yield* Git.Service
+      const branch = yield* git.branch(tmp.path)
       expect(branch).toBeUndefined()
-    })
-  })
+    }),
+  )
 
-  test("defaultBranch() uses init.defaultBranch when available", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await $`git branch -M trunk`.cwd(tmp.path).quiet()
-    await $`git config init.defaultBranch trunk`.cwd(tmp.path).quiet()
-
-    await withGit(async (rt) => {
-      const branch = await rt.runPromise(Git.Service.use((git) => git.defaultBranch(tmp.path)))
+  it.live("defaultBranch() uses init.defaultBranch when available", () =>
+    Effect.gen(function* () {
+      const tmp = yield* scopedTmpdir({ git: true })
+      yield* Effect.promise(() => $`git branch -M trunk`.cwd(tmp.path).quiet())
+      yield* Effect.promise(() => $`git config init.defaultBranch trunk`.cwd(tmp.path).quiet())
+      const git = yield* Git.Service
+      const branch = yield* git.defaultBranch(tmp.path)
       expect(branch?.name).toBe("trunk")
       expect(branch?.ref).toBe("trunk")
-    })
-  })
+    }),
+  )
 
-  test("status() handles special filenames", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await fs.writeFile(path.join(tmp.path, weird), "hello\n", "utf-8")
-
-    await withGit(async (rt) => {
-      const status = await rt.runPromise(Git.Service.use((git) => git.status(tmp.path)))
+  it.live("status() handles special filenames", () =>
+    Effect.gen(function* () {
+      const tmp = yield* scopedTmpdir({ git: true })
+      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "hello\n", "utf-8"))
+      const git = yield* Git.Service
+      const status = yield* git.status(tmp.path)
       expect(status).toEqual(
         expect.arrayContaining([
           expect.objectContaining({
@@ -74,23 +73,24 @@ describe("Git", () => {
           }),
         ]),
       )
-    })
-  })
+    }),
+  )
 
-  test("diff(), stats(), and mergeBase() parse tracked changes", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await $`git branch -M main`.cwd(tmp.path).quiet()
-    await fs.writeFile(path.join(tmp.path, weird), "before\n", "utf-8")
-    await $`git add .`.cwd(tmp.path).quiet()
-    await $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet()
-    await $`git checkout -b feature/test`.cwd(tmp.path).quiet()
-    await fs.writeFile(path.join(tmp.path, weird), "after\n", "utf-8")
+  it.live("diff(), stats(), and mergeBase() parse tracked changes", () =>
+    Effect.gen(function* () {
+      const tmp = yield* scopedTmpdir({ git: true })
+      yield* Effect.promise(() => $`git branch -M main`.cwd(tmp.path).quiet())
+      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "before\n", "utf-8"))
+      yield* Effect.promise(() => $`git add .`.cwd(tmp.path).quiet())
+      yield* Effect.promise(() => $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet())
+      yield* Effect.promise(() => $`git checkout -b feature/test`.cwd(tmp.path).quiet())
+      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "after\n", "utf-8"))
 
-    await withGit(async (rt) => {
-      const [base, diff, stats] = await Promise.all([
-        rt.runPromise(Git.Service.use((git) => git.mergeBase(tmp.path, "main"))),
-        rt.runPromise(Git.Service.use((git) => git.diff(tmp.path, "HEAD"))),
-        rt.runPromise(Git.Service.use((git) => git.stats(tmp.path, "HEAD"))),
+      const git = yield* Git.Service
+      const [base, diff, stats] = yield* Effect.all([
+        git.mergeBase(tmp.path, "main"),
+        git.diff(tmp.path, "HEAD"),
+        git.stats(tmp.path, "HEAD"),
       ])
 
       expect(base).toBeTruthy()
@@ -111,23 +111,24 @@ describe("Git", () => {
           }),
         ]),
       )
-    })
-  })
+    }),
+  )
 
-  test("patch() returns capped native patch output", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await fs.writeFile(path.join(tmp.path, weird), "before\n", "utf-8")
-    await fs.writeFile(path.join(tmp.path, "other.txt"), "old\n", "utf-8")
-    await $`git add .`.cwd(tmp.path).quiet()
-    await $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet()
-    await fs.writeFile(path.join(tmp.path, weird), "after\n", "utf-8")
-    await fs.writeFile(path.join(tmp.path, "other.txt"), "new\n", "utf-8")
+  it.live("patch() returns capped native patch output", () =>
+    Effect.gen(function* () {
+      const tmp = yield* scopedTmpdir({ git: true })
+      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "before\n", "utf-8"))
+      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "other.txt"), "old\n", "utf-8"))
+      yield* Effect.promise(() => $`git add .`.cwd(tmp.path).quiet())
+      yield* Effect.promise(() => $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet())
+      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "after\n", "utf-8"))
+      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "other.txt"), "new\n", "utf-8"))
 
-    await withGit(async (rt) => {
-      const [patch, all, capped] = await Promise.all([
-        rt.runPromise(Git.Service.use((git) => git.patch(tmp.path, "HEAD", weird, { context: 2_147_483_647 }))),
-        rt.runPromise(Git.Service.use((git) => git.patchAll(tmp.path, "HEAD", { context: 2_147_483_647 }))),
-        rt.runPromise(Git.Service.use((git) => git.patch(tmp.path, "HEAD", weird, { maxOutputBytes: 1 }))),
+      const git = yield* Git.Service
+      const [patch, all, capped] = yield* Effect.all([
+        git.patch(tmp.path, "HEAD", weird, { context: 2_147_483_647 }),
+        git.patchAll(tmp.path, "HEAD", { context: 2_147_483_647 }),
+        git.patch(tmp.path, "HEAD", weird, { maxOutputBytes: 1 }),
       ])
 
       expect(patch.truncated).toBe(false)
@@ -140,17 +141,18 @@ describe("Git", () => {
       expect(all.text).toContain("+new")
       expect(capped.truncated).toBe(true)
       expect(capped.text).toBe("")
-    })
-  })
+    }),
+  )
 
-  test("patchUntracked() and statUntracked() handle added files", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await fs.writeFile(path.join(tmp.path, weird), "one\ntwo\n", "utf-8")
+  it.live("patchUntracked() and statUntracked() handle added files", () =>
+    Effect.gen(function* () {
+      const tmp = yield* scopedTmpdir({ git: true })
+      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "one\ntwo\n", "utf-8"))
 
-    await withGit(async (rt) => {
-      const [patch, stat] = await Promise.all([
-        rt.runPromise(Git.Service.use((git) => git.patchUntracked(tmp.path, weird, { context: 2_147_483_647 }))),
-        rt.runPromise(Git.Service.use((git) => git.statUntracked(tmp.path, weird))),
+      const git = yield* Git.Service
+      const [patch, stat] = yield* Effect.all([
+        git.patchUntracked(tmp.path, weird, { context: 2_147_483_647 }),
+        git.statUntracked(tmp.path, weird),
       ])
 
       expect(patch.truncated).toBe(false)
@@ -158,18 +160,19 @@ describe("Git", () => {
       expect(patch.text).toContain("+one")
       expect(patch.text).toContain("+two")
       expect(stat).toEqual(expect.objectContaining({ file: weird, additions: 2, deletions: 0 }))
-    })
-  })
+    }),
+  )
 
-  test("show() returns empty text for binary blobs", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await fs.writeFile(path.join(tmp.path, "bin.dat"), new Uint8Array([0, 1, 2, 3]))
-    await $`git add .`.cwd(tmp.path).quiet()
-    await $`git commit --no-gpg-sign -m "add binary"`.cwd(tmp.path).quiet()
+  it.live("show() returns empty text for binary blobs", () =>
+    Effect.gen(function* () {
+      const tmp = yield* scopedTmpdir({ git: true })
+      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "bin.dat"), new Uint8Array([0, 1, 2, 3])))
+      yield* Effect.promise(() => $`git add .`.cwd(tmp.path).quiet())
+      yield* Effect.promise(() => $`git commit --no-gpg-sign -m "add binary"`.cwd(tmp.path).quiet())
 
-    await withGit(async (rt) => {
-      const text = await rt.runPromise(Git.Service.use((git) => git.show(tmp.path, "HEAD", "bin.dat")))
+      const git = yield* Git.Service
+      const text = yield* git.show(tmp.path, "HEAD", "bin.dat")
       expect(text).toBe("")
-    })
-  })
+    }),
+  )
 })

packages/opencode/test/plugin/auth-override.test.ts

@@ -1,15 +1,19 @@
 import { describe, expect, test } from "bun:test"
 import path from "path"
-import fs from "fs/promises"
 import { pathToFileURL } from "url"
 import { Effect, Layer } from "effect"
-import { provideTestInstance, tmpdir } from "../fixture/fixture"
+import { AppFileSystem } from "@opencode-ai/core/filesystem"
+import { provideInstance, TestInstance, tmpdirScoped } from "../fixture/fixture"
 import { ProviderAuth } from "@/provider/auth"
 import { ProviderID } from "../../src/provider/schema"
 import { Plugin } from "@/plugin"
 import { Auth } from "@/auth"
 import { Bus } from "@/bus"
 import { TestConfig } from "../fixture/config"
+import { testEffect } from "../lib/effect"
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+
+const it = testEffect(Layer.mergeAll(CrossSpawnSpawner.defaultLayer, AppFileSystem.defaultLayer))
 
 function layer(directory: string, plugins: string[]) {
   return ProviderAuth.layer.pipe(
@@ -37,13 +41,15 @@ function layer(directory: string, plugins: string[]) {
 }
 
 describe("plugin.auth-override", () => {
-  test("user plugin overrides built-in github-copilot auth", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        const pluginDir = path.join(dir, ".opencode", "plugin")
-        await fs.mkdir(pluginDir, { recursive: true })
+  it.instance(
+    "user plugin overrides built-in github-copilot auth",
+    () =>
+      Effect.gen(function* () {
+        const tmp = yield* TestInstance
+        const fs = yield* AppFileSystem.Service
+        const pluginDir = path.join(tmp.directory, ".opencode", "plugin")
 
-        await Bun.write(
+        yield* fs.writeWithDirs(
           path.join(pluginDir, "custom-copilot-auth.ts"),
           [
             "export default {",
@@ -61,37 +67,26 @@ describe("plugin.auth-override", () => {
             "",
           ].join("\n"),
         )
-      },
-    })
 
-    await using plain = await tmpdir()
+        const plain = yield* tmpdirScoped({ git: true })
+        const plugin = pathToFileURL(path.join(pluginDir, "custom-copilot-auth.ts")).href
+        const methods = yield* ProviderAuth.Service.use((svc) => svc.methods()).pipe(
+          Effect.provide(layer(tmp.directory, [plugin])),
+        )
+        const plainMethods = yield* ProviderAuth.Service.use((svc) => svc.methods()).pipe(
+          Effect.provide(layer(plain, [])),
+          provideInstance(plain),
+        )
 
-    const plugin = pathToFileURL(path.join(tmp.path, ".opencode", "plugin", "custom-copilot-auth.ts")).href
-    const [methods, plainMethods] = await Promise.all([
-      provideTestInstance({
-        directory: tmp.path,
-        fn: async () => {
-          return Effect.runPromise(
-            ProviderAuth.Service.use((svc) => svc.methods()).pipe(Effect.provide(layer(tmp.path, [plugin]))),
-          )
-        },
+        const copilot = methods[ProviderID.make("github-copilot")]
+        expect(copilot).toBeDefined()
+        expect(copilot.length).toBe(1)
+        expect(copilot[0].label).toBe("Test Override Auth")
+        expect(plainMethods[ProviderID.make("github-copilot")][0].label).not.toBe("Test Override Auth")
       }),
-      provideTestInstance({
-        directory: plain.path,
-        fn: async () => {
-          return Effect.runPromise(
-            ProviderAuth.Service.use((svc) => svc.methods()).pipe(Effect.provide(layer(plain.path, []))),
-          )
-        },
-      }),
-    ])
-
-    const copilot = methods[ProviderID.make("github-copilot")]
-    expect(copilot).toBeDefined()
-    expect(copilot.length).toBe(1)
-    expect(copilot[0].label).toBe("Test Override Auth")
-    expect(plainMethods[ProviderID.make("github-copilot")][0].label).not.toBe("Test Override Auth")
-  }, 30000)
+    { git: true },
+    30000,
+  )
 })
 
 const file = path.join(import.meta.dir, "../../src/plugin/index.ts")

packages/opencode/test/project/instance.test.ts

@@ -1,13 +1,12 @@
 import { afterEach, describe, expect } from "bun:test"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
-import { Effect, Fiber, Layer } from "effect"
+import { Deferred, Effect, Fiber, Layer } from "effect"
 import { InstanceRef } from "../../src/effect/instance-ref"
 import { registerDisposer } from "../../src/effect/instance-registry"
 import { InstanceBootstrap } from "../../src/project/bootstrap-service"
 import { Instance } from "../../src/project/instance"
-import { WithInstance } from "../../src/project/with-instance"
 import { InstanceStore } from "../../src/project/instance-store"
-import { disposeAllInstances, tmpdirScoped } from "../fixture/fixture"
+import { disposeAllInstances, TestInstance, tmpdirScoped } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
 
 let bootstrapRun: Effect.Effect<void> = Effect.void
@@ -75,18 +74,18 @@ describe("InstanceStore", () => {
     Effect.gen(function* () {
       const dir = yield* tmpdirScoped({ git: true })
       const store = yield* InstanceStore.Service
-      const started = Promise.withResolvers<void>()
-      const release = Promise.withResolvers<void>()
+      const started = yield* Deferred.make<void>()
+      const release = yield* Deferred.make<void>()
       let initialized = 0
 
-      bootstrapRun = Effect.promise(async () => {
+      bootstrapRun = Effect.gen(function* () {
         initialized++
-        started.resolve()
-        await release.promise
+        yield* Deferred.succeed(started, undefined)
+        yield* Deferred.await(release)
       })
       const first = yield* store.load({ directory: dir }).pipe(Effect.forkScoped)
 
-      yield* Effect.promise(() => started.promise)
+      yield* Deferred.await(started)
 
       bootstrapRun = Effect.sync(() => {
         initialized++
@@ -94,7 +93,7 @@ describe("InstanceStore", () => {
       const second = yield* store.load({ directory: dir }).pipe(Effect.forkScoped)
 
       expect(initialized).toBe(1)
-      release.resolve()
+      yield* Deferred.succeed(release, undefined)
 
       const [firstCtx, secondCtx] = yield* Effect.all([Fiber.join(first), Fiber.join(second)])
       expect(secondCtx).toBe(firstCtx)
@@ -147,8 +146,8 @@ describe("InstanceStore", () => {
     Effect.gen(function* () {
       const dir = yield* tmpdirScoped({ git: true })
       const store = yield* InstanceStore.Service
-      const reloading = Promise.withResolvers<void>()
-      const releaseReload = Promise.withResolvers<void>()
+      const reloading = yield* Deferred.make<void>()
+      const releaseReload = yield* Deferred.make<void>()
       const disposed: Array<string> = []
       const off = registerDisposer(async (directory) => {
         disposed.push(directory)
@@ -156,15 +155,15 @@ describe("InstanceStore", () => {
       yield* Effect.addFinalizer(() => Effect.sync(off))
 
       const first = yield* store.load({ directory: dir })
-      bootstrapRun = Effect.promise(async () => {
-        reloading.resolve()
-        await releaseReload.promise
+      bootstrapRun = Effect.gen(function* () {
+        yield* Deferred.succeed(reloading, undefined)
+        yield* Deferred.await(releaseReload)
       })
       const reload = yield* store.reload({ directory: dir }).pipe(Effect.forkScoped)
 
-      yield* Effect.promise(() => reloading.promise)
+      yield* Deferred.await(reloading)
       const staleDispose = yield* store.dispose(first).pipe(Effect.forkScoped)
-      releaseReload.resolve()
+      yield* Deferred.succeed(releaseReload, undefined)
 
       const second = yield* Fiber.join(reload)
       yield* Fiber.join(staleDispose)
@@ -178,23 +177,23 @@ describe("InstanceStore", () => {
     Effect.gen(function* () {
       const dir = yield* tmpdirScoped({ git: true })
       const store = yield* InstanceStore.Service
-      const disposing = Promise.withResolvers<void>()
-      const releaseDispose = Promise.withResolvers<void>()
+      const disposing = yield* Deferred.make<void>()
+      const releaseDispose = yield* Deferred.make<void>()
       const disposed: Array<string> = []
       const off = registerDisposer(async (directory) => {
         disposed.push(directory)
-        disposing.resolve()
-        await releaseDispose.promise
+        Deferred.doneUnsafe(disposing, Effect.void)
+        await Effect.runPromise(Deferred.await(releaseDispose))
       })
       yield* Effect.addFinalizer(() => Effect.sync(off))
 
       yield* store.load({ directory: dir })
       const first = yield* store.disposeAll().pipe(Effect.forkScoped)
-      yield* Effect.promise(() => disposing.promise)
+      yield* Deferred.await(disposing)
       const second = yield* store.disposeAll().pipe(Effect.forkScoped)
 
       expect(disposed).toEqual([dir])
-      releaseDispose.resolve()
+      yield* Deferred.succeed(releaseDispose, undefined)
       yield* Effect.all([Fiber.join(first), Fiber.join(second)])
       expect(disposed).toEqual([dir])
     }),
@@ -221,19 +220,19 @@ describe("InstanceStore", () => {
     }),
   )
 
-  it.live("provides legacy Promise callers with instance ALS", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
+  it.instance(
+    "provides legacy Promise callers with instance ALS",
+    () =>
+      Effect.gen(function* () {
+        const test = yield* TestInstance
+        const ctx = yield* InstanceRef
+        if (!ctx) throw new Error("InstanceRef not provided")
 
-      const directory = yield* Effect.promise(() =>
-        WithInstance.provide({
-          directory: dir,
-          fn: () => Instance.directory,
-        }),
-      )
+        const directory = yield* Effect.promise(() => Promise.resolve(Instance.restore(ctx, () => Instance.directory)))
 
-      expect(directory).toBe(dir)
-      expect(() => Instance.current).toThrow()
-    }),
+        expect(directory).toBe(test.directory)
+        expect(() => Instance.current).toThrow()
+      }),
+    { git: true },
   )
 })

packages/opencode/test/provider/provider.test.ts

@@ -582,64 +582,52 @@ it.instance(
   },
 )
 
-test("model options are merged from existing model", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(
-        path.join(dir, "opencode.json"),
-        JSON.stringify({
-          $schema: "https://opencode.ai/config.json",
-          provider: {
-            anthropic: {
-              models: {
-                "claude-sonnet-4-20250514": {
-                  options: {
-                    customOption: "custom-value",
-                  },
-                },
+it.instance(
+  "model options are merged from existing model",
+  Effect.gen(function* () {
+    const providers = yield* Provider.Service.use((provider) => provider.list())
+    const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
+    expect(model.options.customOption).toBe("custom-value")
+  }),
+  {
+    config: {
+      provider: {
+        anthropic: {
+          options: {
+            apiKey: "test-api-key",
+          },
+          models: {
+            "claude-sonnet-4-20250514": {
+              options: {
+                customOption: "custom-value",
               },
             },
           },
-        }),
-      )
+        },
+      },
     },
-  })
-  await WithInstance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      set("ANTHROPIC_API_KEY", "test-api-key")
-      const providers = await list()
-      const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
-      expect(model.options.customOption).toBe("custom-value")
-    },
-  })
-})
+  },
+)
 
-test("provider removed when all models filtered out", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(
-        path.join(dir, "opencode.json"),
-        JSON.stringify({
-          $schema: "https://opencode.ai/config.json",
-          provider: {
-            anthropic: {
-              whitelist: ["nonexistent-model"],
-            },
+it.instance(
+  "provider removed when all models filtered out",
+  Effect.gen(function* () {
+    const providers = yield* Provider.Service.use((provider) => provider.list())
+    expect(providers[ProviderID.anthropic]).toBeUndefined()
+  }),
+  {
+    config: {
+      provider: {
+        anthropic: {
+          options: {
+            apiKey: "test-api-key",
           },
-        }),
-      )
+          whitelist: ["nonexistent-model"],
+        },
+      },
     },
-  })
-  await WithInstance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      set("ANTHROPIC_API_KEY", "test-api-key")
-      const providers = await list()
-      expect(providers[ProviderID.anthropic]).toBeUndefined()
-    },
-  })
-})
+  },
+)
 
 test("closest finds model by partial match", async () => {
   await using tmp = await tmpdir({

packages/opencode/test/question/question.test.ts

@@ -2,7 +2,6 @@ import { afterEach, expect } from "bun:test"
 import { Cause, Effect, Exit, Fiber, Layer } from "effect"
 import { Question } from "../../src/question"
 import { Instance } from "../../src/project/instance"
-import { WithInstance } from "../../src/project/with-instance"
 import { InstanceRuntime } from "../../src/project/instance-runtime"
 import { QuestionID } from "../../src/question/schema"
 import { disposeAllInstances, provideInstance, reloadTestInstance, tmpdirScoped } from "../fixture/fixture"
@@ -398,9 +397,8 @@ it.live("pending question rejects on instance dispose", () =>
     }).pipe(provideInstance(dir), Effect.forkScoped)
 
     expect(yield* waitForPending(1).pipe(provideInstance(dir))).toHaveLength(1)
-    yield* Effect.promise(() =>
-      WithInstance.provide({ directory: dir, fn: () => InstanceRuntime.disposeInstance(Instance.current) }),
-    )
+    const ctx = yield* Effect.sync(() => Instance.current).pipe(provideInstance(dir))
+    yield* Effect.promise(() => InstanceRuntime.disposeInstance(ctx))
 
     const exit = yield* Fiber.await(fiber)
     expect(Exit.isFailure(exit)).toBe(true)

packages/opencode/test/server/session-list.test.ts

@@ -1,33 +1,25 @@
-import { afterEach, describe, expect, test } from "bun:test"
+import { afterEach, describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Instance } from "../../src/project/instance"
-import { WithInstance } from "../../src/project/with-instance"
 import { Session as SessionNs } from "@/session/session"
 import * as Log from "@opencode-ai/core/util/log"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
+import { disposeAllInstances, provideInstance, TestInstance } from "../fixture/fixture"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { mkdir } from "fs/promises"
 import path from "path"
 import { Database } from "@/storage/db"
 import { SessionTable } from "@/session/session.sql"
 import { eq } from "drizzle-orm"
+import { testEffect } from "../lib/effect"
 
 void Log.init({ print: false })
 const originalWorkspaces = Flag.OPENCODE_EXPERIMENTAL_WORKSPACES
+const it = testEffect(SessionNs.defaultLayer)
 
-function run<A, E>(fx: Effect.Effect<A, E, SessionNs.Service>) {
-  return Effect.runPromise(fx.pipe(Effect.provide(SessionNs.defaultLayer)))
-}
-
-const svc = {
-  ...SessionNs,
-  create(input?: SessionNs.CreateInput) {
-    return run(SessionNs.Service.use((svc) => svc.create(input)))
-  },
-  list(input?: SessionNs.ListInput) {
-    return run(SessionNs.Service.use((svc) => svc.list(input)))
-  },
-}
+const withSession = (input?: Parameters<SessionNs.Interface["create"]>[0]) =>
+  Effect.acquireRelease(
+    SessionNs.Service.use((session) => session.create(input)),
+    (created) => SessionNs.Service.use((session) => session.remove(created.id).pipe(Effect.ignore)),
+  )
 
 afterEach(async () => {
   Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = originalWorkspaces
@@ -35,205 +27,199 @@ afterEach(async () => {
 })
 
 describe("session.list", () => {
-  test("does not filter by directory when directory is omitted", async () => {
-    Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = false
-    await using tmp = await tmpdir({ git: true })
-    await mkdir(path.join(tmp.path, "packages", "opencode"), { recursive: true })
-    await mkdir(path.join(tmp.path, "packages", "app"), { recursive: true })
+  it.instance(
+    "does not filter by directory when directory is omitted",
+    () =>
+      Effect.gen(function* () {
+        Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = false
+        const test = yield* TestInstance
+        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "opencode"), { recursive: true }))
+        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "app"), { recursive: true }))
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const root = await svc.create({ title: "root" })
+        const root = yield* withSession({ title: "root" })
+        const parent = yield* withSession({ title: "parent" }).pipe(
+          provideInstance(path.join(test.directory, "packages")),
+        )
+        const current = yield* withSession({ title: "current" }).pipe(
+          provideInstance(path.join(test.directory, "packages", "opencode")),
+        )
+        const sibling = yield* withSession({ title: "sibling" }).pipe(
+          provideInstance(path.join(test.directory, "packages", "app")),
+        )
 
-        const parent = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages"),
-          fn: async () => svc.create({ title: "parent" }),
-        })
-        const current = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages", "opencode"),
-          fn: async () => svc.create({ title: "current" }),
-        })
-        const sibling = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages", "app"),
-          fn: async () => svc.create({ title: "sibling" }),
-        })
-
-        const ids = (await svc.list()).map((s) => s.id)
+        const ids = (yield* SessionNs.Service.use((session) => session.list())).map((session) => session.id)
         expect(ids).toContain(root.id)
         expect(ids).toContain(parent.id)
         expect(ids).toContain(current.id)
         expect(ids).toContain(sibling.id)
-      },
-    })
-  })
+      }),
+    { git: true },
+  )
 
-  test("filters by directory when directory is provided", async () => {
-    Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = false
-    await using tmp = await tmpdir({ git: true })
-    await mkdir(path.join(tmp.path, "packages", "opencode"), { recursive: true })
-    await mkdir(path.join(tmp.path, "packages", "app"), { recursive: true })
+  it.instance(
+    "filters by directory when directory is provided",
+    () =>
+      Effect.gen(function* () {
+        Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = false
+        const test = yield* TestInstance
+        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "opencode"), { recursive: true }))
+        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "app"), { recursive: true }))
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const root = await svc.create({ title: "root" })
+        const root = yield* withSession({ title: "root" })
+        const parent = yield* withSession({ title: "parent" }).pipe(
+          provideInstance(path.join(test.directory, "packages")),
+        )
+        const current = yield* withSession({ title: "current" }).pipe(
+          provideInstance(path.join(test.directory, "packages", "opencode")),
+        )
+        const sibling = yield* withSession({ title: "sibling" }).pipe(
+          provideInstance(path.join(test.directory, "packages", "app")),
+        )
 
-        const parent = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages"),
-          fn: async () => svc.create({ title: "parent" }),
-        })
-        const current = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages", "opencode"),
-          fn: async () => svc.create({ title: "current" }),
-        })
-        const sibling = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages", "app"),
-          fn: async () => svc.create({ title: "sibling" }),
-        })
-
-        const ids = (await svc.list({ directory: path.join(tmp.path, "packages", "opencode") })).map((s) => s.id)
+        const ids = (yield* SessionNs.Service.use((session) =>
+          session.list({ directory: path.join(test.directory, "packages", "opencode") }),
+        )).map((session) => session.id)
         expect(ids).not.toContain(root.id)
         expect(ids).not.toContain(parent.id)
         expect(ids).toContain(current.id)
         expect(ids).not.toContain(sibling.id)
-      },
-    })
-  })
+      }),
+    { git: true },
+  )
 
-  test("filters by path and ignores directory when path is provided", async () => {
-    Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = false
-    await using tmp = await tmpdir({ git: true })
-    await mkdir(path.join(tmp.path, "packages", "opencode", "src", "deep"), { recursive: true })
-    await mkdir(path.join(tmp.path, "packages", "app"), { recursive: true })
+  it.instance(
+    "filters by path and ignores directory when path is provided",
+    () =>
+      Effect.gen(function* () {
+        Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = false
+        const test = yield* TestInstance
+        yield* Effect.promise(() =>
+          mkdir(path.join(test.directory, "packages", "opencode", "src", "deep"), { recursive: true }),
+        )
+        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "app"), { recursive: true }))
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const parent = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages", "opencode"),
-          fn: async () => svc.create({ title: "parent" }),
-        })
-        const current = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages", "opencode", "src"),
-          fn: async () => svc.create({ title: "current" }),
-        })
-        const deeper = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages", "opencode", "src", "deep"),
-          fn: async () => svc.create({ title: "deeper" }),
-        })
-        const sibling = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages", "app"),
-          fn: async () => svc.create({ title: "sibling" }),
-        })
+        const parent = yield* withSession({ title: "parent" }).pipe(
+          provideInstance(path.join(test.directory, "packages", "opencode")),
+        )
+        const current = yield* withSession({ title: "current" }).pipe(
+          provideInstance(path.join(test.directory, "packages", "opencode", "src")),
+        )
+        const deeper = yield* withSession({ title: "deeper" }).pipe(
+          provideInstance(path.join(test.directory, "packages", "opencode", "src", "deep")),
+        )
+        const sibling = yield* withSession({ title: "sibling" }).pipe(
+          provideInstance(path.join(test.directory, "packages", "app")),
+        )
 
-        const pathIDs = (
-          await svc.list({
-            directory: path.join(tmp.path, "packages", "app"),
+        const pathIDs = (yield* SessionNs.Service.use((session) =>
+          session.list({
+            directory: path.join(test.directory, "packages", "app"),
             path: "packages/opencode/src",
-          })
-        ).map((s) => s.id)
+          }),
+        )).map((session) => session.id)
         expect(pathIDs).not.toContain(parent.id)
         expect(pathIDs).toContain(current.id)
         expect(pathIDs).toContain(deeper.id)
         expect(pathIDs).not.toContain(sibling.id)
-      },
-    })
-  })
+      }),
+    { git: true },
+  )
 
-  test("falls back to directory when filtering legacy sessions without path", async () => {
-    Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = false
-    await using tmp = await tmpdir({ git: true })
-    await mkdir(path.join(tmp.path, "packages", "opencode", "src"), { recursive: true })
-    await mkdir(path.join(tmp.path, "packages", "app"), { recursive: true })
+  it.instance(
+    "falls back to directory when filtering legacy sessions without path",
+    () =>
+      Effect.gen(function* () {
+        Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = false
+        const test = yield* TestInstance
+        yield* Effect.promise(() =>
+          mkdir(path.join(test.directory, "packages", "opencode", "src"), { recursive: true }),
+        )
+        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "app"), { recursive: true }))
 
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const current = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages", "opencode", "src"),
-          fn: async () => svc.create({ title: "legacy-current" }),
-        })
-        const sibling = await WithInstance.provide({
-          directory: path.join(tmp.path, "packages", "app"),
-          fn: async () => svc.create({ title: "legacy-sibling" }),
-        })
+        const current = yield* withSession({ title: "legacy-current" }).pipe(
+          provideInstance(path.join(test.directory, "packages", "opencode", "src")),
+        )
+        const sibling = yield* withSession({ title: "legacy-sibling" }).pipe(
+          provideInstance(path.join(test.directory, "packages", "app")),
+        )
 
-        Database.use((db) => db.update(SessionTable).set({ path: null }).where(eq(SessionTable.id, current.id)).run())
-        Database.use((db) => db.update(SessionTable).set({ path: null }).where(eq(SessionTable.id, sibling.id)).run())
+        yield* Effect.sync(() =>
+          Database.use((db) =>
+            db.update(SessionTable).set({ path: null }).where(eq(SessionTable.id, current.id)).run(),
+          ),
+        )
+        yield* Effect.sync(() =>
+          Database.use((db) =>
+            db.update(SessionTable).set({ path: null }).where(eq(SessionTable.id, sibling.id)).run(),
+          ),
+        )
 
-        const pathIDs = (
-          await svc.list({
-            directory: path.join(tmp.path, "packages", "opencode", "src"),
+        const pathIDs = (yield* SessionNs.Service.use((session) =>
+          session.list({
+            directory: path.join(test.directory, "packages", "opencode", "src"),
             path: "packages/opencode/src",
-          })
-        ).map((s) => s.id)
+          }),
+        )).map((session) => session.id)
         expect(pathIDs).toContain(current.id)
         expect(pathIDs).not.toContain(sibling.id)
-      },
-    })
-  })
+      }),
+    { git: true },
+  )
 
-  test("filters root sessions", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const root = await svc.create({ title: "root-session" })
-        const child = await svc.create({ title: "child-session", parentID: root.id })
+  it.instance(
+    "filters root sessions",
+    () =>
+      Effect.gen(function* () {
+        const root = yield* withSession({ title: "root-session" })
+        const child = yield* withSession({ title: "child-session", parentID: root.id })
 
-        const sessions = await svc.list({ roots: true })
-        const ids = sessions.map((s) => s.id)
+        const sessions = yield* SessionNs.Service.use((session) => session.list({ roots: true }))
+        const ids = sessions.map((session) => session.id)
 
         expect(ids).toContain(root.id)
         expect(ids).not.toContain(child.id)
-      },
-    })
-  })
+      }),
+    { git: true },
+  )
 
-  test("filters by start time", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await svc.create({ title: "new-session" })
-        const futureStart = Date.now() + 86400000
-
-        const sessions = await svc.list({ start: futureStart })
+  it.instance(
+    "filters by start time",
+    () =>
+      Effect.gen(function* () {
+        yield* withSession({ title: "new-session" })
+        const sessions = yield* SessionNs.Service.use((session) => session.list({ start: Date.now() + 86400000 }))
         expect(sessions.length).toBe(0)
-      },
-    })
-  })
+      }),
+    { git: true },
+  )
 
-  test("filters by search term", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await svc.create({ title: "unique-search-term-abc" })
-        await svc.create({ title: "other-session-xyz" })
+  it.instance(
+    "filters by search term",
+    () =>
+      Effect.gen(function* () {
+        yield* withSession({ title: "unique-search-term-abc" })
+        yield* withSession({ title: "other-session-xyz" })
 
-        const sessions = await svc.list({ search: "unique-search" })
-        const titles = sessions.map((s) => s.title)
+        const sessions = yield* SessionNs.Service.use((session) => session.list({ search: "unique-search" }))
+        const titles = sessions.map((session) => session.title)
 
         expect(titles).toContain("unique-search-term-abc")
         expect(titles).not.toContain("other-session-xyz")
-      },
-    })
-  })
+      }),
+    { git: true },
+  )
 
-  test("respects limit parameter", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await svc.create({ title: "session-1" })
-        await svc.create({ title: "session-2" })
-        await svc.create({ title: "session-3" })
+  it.instance(
+    "respects limit parameter",
+    () =>
+      Effect.gen(function* () {
+        yield* withSession({ title: "session-1" })
+        yield* withSession({ title: "session-2" })
+        yield* withSession({ title: "session-3" })
 
-        const sessions = await svc.list({ limit: 2 })
+        const sessions = yield* SessionNs.Service.use((session) => session.list({ limit: 2 }))
         expect(sessions.length).toBe(2)
-      },
-    })
-  })
+      }),
+    { git: true },
+  )
 })

packages/opencode/test/session/compaction.test.ts

@@ -28,7 +28,6 @@ import { testEffect } from "../lib/effect"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { TestConfig } from "../fixture/config"
 import { SyncEvent } from "@/sync"
-import { LLMEvent, Usage } from "@opencode-ai/llm"
 
 void Log.init({ print: false })
 
@@ -46,10 +45,6 @@ const ref = {
   modelID: ModelID.make("test-model"),
 }
 
-const usage = (input: ConstructorParameters<typeof Usage>[0]) => new Usage(input)
-
-const basicUsage = () => usage({ inputTokens: 1, outputTokens: 1, totalTokens: 2 })
-
 afterEach(() => {
   mock.restore()
 })
@@ -294,11 +289,11 @@ function readCompactionPart(sessionID: SessionID) {
 
 function llm() {
   const queue: Array<
-    Stream.Stream<LLMEvent, unknown> | ((input: LLM.StreamInput) => Stream.Stream<LLMEvent, unknown>)
+    Stream.Stream<LLM.Event, unknown> | ((input: LLM.StreamInput) => Stream.Stream<LLM.Event, unknown>)
   > = []
 
   return {
-    push(stream: Stream.Stream<LLMEvent, unknown> | ((input: LLM.StreamInput) => Stream.Stream<LLMEvent, unknown>)) {
+    push(stream: Stream.Stream<LLM.Event, unknown> | ((input: LLM.StreamInput) => Stream.Stream<LLM.Event, unknown>)) {
       queue.push(stream)
     },
     layer: Layer.succeed(
@@ -317,22 +312,54 @@ function llm() {
 function reply(
   text: string,
   capture?: (input: LLM.StreamInput) => void,
-): (input: LLM.StreamInput) => Stream.Stream<LLMEvent, unknown> {
+): (input: LLM.StreamInput) => Stream.Stream<LLM.Event, unknown> {
   return (input) => {
     capture?.(input)
     return Stream.make(
-      LLMEvent.textStart({ id: "txt-0" }),
-      LLMEvent.textDelta({ id: "txt-0", text }),
-      LLMEvent.textEnd({ id: "txt-0" }),
-      LLMEvent.stepFinish({
-        index: 0,
-        reason: "stop",
-        usage: basicUsage(),
-      }),
-      LLMEvent.requestFinish({
-        reason: "stop",
-        usage: basicUsage(),
-      }),
+      { type: "start" } satisfies LLM.Event,
+      { type: "text-start", id: "txt-0" } satisfies LLM.Event,
+      { type: "text-delta", id: "txt-0", delta: text, text } as LLM.Event,
+      { type: "text-end", id: "txt-0" } satisfies LLM.Event,
+      {
+        type: "finish-step",
+        finishReason: "stop",
+        rawFinishReason: "stop",
+        response: { id: "res", modelId: "test-model", timestamp: new Date() },
+        providerMetadata: undefined,
+        usage: {
+          inputTokens: 1,
+          outputTokens: 1,
+          totalTokens: 2,
+          inputTokenDetails: {
+            noCacheTokens: undefined,
+            cacheReadTokens: undefined,
+            cacheWriteTokens: undefined,
+          },
+          outputTokenDetails: {
+            textTokens: undefined,
+            reasoningTokens: undefined,
+          },
+        },
+      } satisfies LLM.Event,
+      {
+        type: "finish",
+        finishReason: "stop",
+        rawFinishReason: "stop",
+        totalUsage: {
+          inputTokens: 1,
+          outputTokens: 1,
+          totalTokens: 2,
+          inputTokenDetails: {
+            noCacheTokens: undefined,
+            cacheReadTokens: undefined,
+            cacheWriteTokens: undefined,
+          },
+          outputTokenDetails: {
+            textTokens: undefined,
+            reasoningTokens: undefined,
+          },
+        },
+      } satisfies LLM.Event,
     )
   }
 }
@@ -1171,7 +1198,7 @@ describe("session.compaction.process", () => {
         Stream.fromAsyncIterable(
           {
             async *[Symbol.asyncIterator]() {
-              yield LLMEvent.stepStart({ index: 0 })
+              yield { type: "start" } as LLM.Event
               throw new APICallError({
                 message: "boom",
                 url: "https://example.com/v1/chat/completions",
@@ -1263,16 +1290,49 @@ describe("session.compaction.process", () => {
       const stub = llm()
       stub.push(
         Stream.make(
-          LLMEvent.toolCall({ id: "call-1", name: "_noop", input: {} }),
-          LLMEvent.stepFinish({
-            index: 0,
-            reason: "tool-calls",
-            usage: basicUsage(),
-          }),
-          LLMEvent.requestFinish({
-            reason: "tool-calls",
-            usage: basicUsage(),
-          }),
+          { type: "start" } satisfies LLM.Event,
+          { type: "tool-input-start", id: "call-1", toolName: "_noop" } satisfies LLM.Event,
+          { type: "tool-call", toolCallId: "call-1", toolName: "_noop", input: {} } satisfies LLM.Event,
+          {
+            type: "finish-step",
+            finishReason: "tool-calls",
+            rawFinishReason: "tool_calls",
+            response: { id: "res", modelId: "test-model", timestamp: new Date() },
+            providerMetadata: undefined,
+            usage: {
+              inputTokens: 1,
+              outputTokens: 1,
+              totalTokens: 2,
+              inputTokenDetails: {
+                noCacheTokens: undefined,
+                cacheReadTokens: undefined,
+                cacheWriteTokens: undefined,
+              },
+              outputTokenDetails: {
+                textTokens: undefined,
+                reasoningTokens: undefined,
+              },
+            },
+          } satisfies LLM.Event,
+          {
+            type: "finish",
+            finishReason: "tool-calls",
+            rawFinishReason: "tool_calls",
+            totalUsage: {
+              inputTokens: 1,
+              outputTokens: 1,
+              totalTokens: 2,
+              inputTokenDetails: {
+                noCacheTokens: undefined,
+                cacheReadTokens: undefined,
+                cacheWriteTokens: undefined,
+              },
+              outputTokenDetails: {
+                textTokens: undefined,
+                reasoningTokens: undefined,
+              },
+            },
+          } satisfies LLM.Event,
         ),
       )
       return Effect.gen(function* () {
@@ -1483,7 +1543,20 @@ describe("SessionNs.getUsage", () => {
     const model = createModel({ context: 100_000, output: 32_000 })
     const result = SessionNs.getUsage({
       model,
-      usage: usage({ inputTokens: 1000, outputTokens: 500, totalTokens: 1500 }),
+      usage: {
+        inputTokens: 1000,
+        outputTokens: 500,
+        totalTokens: 1500,
+        inputTokenDetails: {
+          noCacheTokens: undefined,
+          cacheReadTokens: undefined,
+          cacheWriteTokens: undefined,
+        },
+        outputTokenDetails: {
+          textTokens: undefined,
+          reasoningTokens: undefined,
+        },
+      },
     })
 
     expect(result.tokens.input).toBe(1000)
@@ -1497,7 +1570,20 @@ describe("SessionNs.getUsage", () => {
     const model = createModel({ context: 100_000, output: 32_000 })
     const result = SessionNs.getUsage({
       model,
-      usage: usage({ inputTokens: 1000, outputTokens: 500, totalTokens: 1500, cacheReadInputTokens: 200 }),
+      usage: {
+        inputTokens: 1000,
+        outputTokens: 500,
+        totalTokens: 1500,
+        inputTokenDetails: {
+          noCacheTokens: 800,
+          cacheReadTokens: 200,
+          cacheWriteTokens: undefined,
+        },
+        outputTokenDetails: {
+          textTokens: undefined,
+          reasoningTokens: undefined,
+        },
+      },
     })
 
     expect(result.tokens.input).toBe(800)
@@ -1508,7 +1594,20 @@ describe("SessionNs.getUsage", () => {
     const model = createModel({ context: 100_000, output: 32_000 })
     const result = SessionNs.getUsage({
       model,
-      usage: usage({ inputTokens: 1000, outputTokens: 500, totalTokens: 1500 }),
+      usage: {
+        inputTokens: 1000,
+        outputTokens: 500,
+        totalTokens: 1500,
+        inputTokenDetails: {
+          noCacheTokens: undefined,
+          cacheReadTokens: undefined,
+          cacheWriteTokens: undefined,
+        },
+        outputTokenDetails: {
+          textTokens: undefined,
+          reasoningTokens: undefined,
+        },
+      },
       metadata: {
         anthropic: {
           cacheCreationInputTokens: 300,
@@ -1524,7 +1623,20 @@ describe("SessionNs.getUsage", () => {
     // AI SDK v6 normalizes inputTokens to include cached tokens for all providers
     const result = SessionNs.getUsage({
       model,
-      usage: usage({ inputTokens: 1000, outputTokens: 500, totalTokens: 1500, cacheReadInputTokens: 200 }),
+      usage: {
+        inputTokens: 1000,
+        outputTokens: 500,
+        totalTokens: 1500,
+        inputTokenDetails: {
+          noCacheTokens: 800,
+          cacheReadTokens: 200,
+          cacheWriteTokens: undefined,
+        },
+        outputTokenDetails: {
+          textTokens: undefined,
+          reasoningTokens: undefined,
+        },
+      },
       metadata: {
         anthropic: {},
       },
@@ -1538,7 +1650,20 @@ describe("SessionNs.getUsage", () => {
     const model = createModel({ context: 100_000, output: 32_000 })
     const result = SessionNs.getUsage({
       model,
-      usage: usage({ inputTokens: 1000, outputTokens: 500, reasoningTokens: 100, totalTokens: 1500 }),
+      usage: {
+        inputTokens: 1000,
+        outputTokens: 500,
+        totalTokens: 1500,
+        inputTokenDetails: {
+          noCacheTokens: undefined,
+          cacheReadTokens: undefined,
+          cacheWriteTokens: undefined,
+        },
+        outputTokenDetails: {
+          textTokens: 400,
+          reasoningTokens: 100,
+        },
+      },
     })
 
     expect(result.tokens.input).toBe(1000)
@@ -1559,7 +1684,20 @@ describe("SessionNs.getUsage", () => {
     })
     const result = SessionNs.getUsage({
       model,
-      usage: usage({ inputTokens: 0, outputTokens: 1_000_000, reasoningTokens: 250_000, totalTokens: 1_000_000 }),
+      usage: {
+        inputTokens: 0,
+        outputTokens: 1_000_000,
+        totalTokens: 1_000_000,
+        inputTokenDetails: {
+          noCacheTokens: undefined,
+          cacheReadTokens: undefined,
+          cacheWriteTokens: undefined,
+        },
+        outputTokenDetails: {
+          textTokens: 750_000,
+          reasoningTokens: 250_000,
+        },
+      },
     })
 
     expect(result.tokens.output).toBe(750_000)
@@ -1571,7 +1709,20 @@ describe("SessionNs.getUsage", () => {
     const model = createModel({ context: 100_000, output: 32_000 })
     const result = SessionNs.getUsage({
       model,
-      usage: usage({ inputTokens: 0, outputTokens: 0, totalTokens: 0 }),
+      usage: {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        inputTokenDetails: {
+          noCacheTokens: undefined,
+          cacheReadTokens: undefined,
+          cacheWriteTokens: undefined,
+        },
+        outputTokenDetails: {
+          textTokens: undefined,
+          reasoningTokens: undefined,
+        },
+      },
     })
 
     expect(result.tokens.input).toBe(0)
@@ -1594,7 +1745,20 @@ describe("SessionNs.getUsage", () => {
     })
     const result = SessionNs.getUsage({
       model,
-      usage: usage({ inputTokens: 1_000_000, outputTokens: 100_000, totalTokens: 1_100_000 }),
+      usage: {
+        inputTokens: 1_000_000,
+        outputTokens: 100_000,
+        totalTokens: 1_100_000,
+        inputTokenDetails: {
+          noCacheTokens: undefined,
+          cacheReadTokens: undefined,
+          cacheWriteTokens: undefined,
+        },
+        outputTokenDetails: {
+          textTokens: undefined,
+          reasoningTokens: undefined,
+        },
+      },
     })
 
     expect(result.cost).toBe(3 + 1.5)
@@ -1605,16 +1769,24 @@ describe("SessionNs.getUsage", () => {
     (npm) => {
       const model = createModel({ context: 100_000, output: 32_000, npm })
       // AI SDK v6: inputTokens includes cached tokens for all providers
-      const item = usage({
+      const usage = {
         inputTokens: 1000,
         outputTokens: 500,
         totalTokens: 1500,
-        cacheReadInputTokens: 200,
-      })
+        inputTokenDetails: {
+          noCacheTokens: 800,
+          cacheReadTokens: 200,
+          cacheWriteTokens: undefined,
+        },
+        outputTokenDetails: {
+          textTokens: undefined,
+          reasoningTokens: undefined,
+        },
+      }
       if (npm === "@ai-sdk/amazon-bedrock") {
         const result = SessionNs.getUsage({
           model,
-          usage: item,
+          usage,
           metadata: {
             bedrock: {
               usage: {
@@ -1635,7 +1807,7 @@ describe("SessionNs.getUsage", () => {
 
       const result = SessionNs.getUsage({
         model,
-        usage: item,
+        usage,
         metadata: {
           anthropic: {
             cacheCreationInputTokens: 300,
@@ -1656,7 +1828,20 @@ describe("SessionNs.getUsage", () => {
     const model = createModel({ context: 100_000, output: 32_000, npm: "@ai-sdk/google-vertex/anthropic" })
     const result = SessionNs.getUsage({
       model,
-      usage: usage({ inputTokens: 1000, outputTokens: 500, totalTokens: 1500, cacheReadInputTokens: 200 }),
+      usage: {
+        inputTokens: 1000,
+        outputTokens: 500,
+        totalTokens: 1500,
+        inputTokenDetails: {
+          noCacheTokens: 800,
+          cacheReadTokens: 200,
+          cacheWriteTokens: undefined,
+        },
+        outputTokenDetails: {
+          textTokens: undefined,
+          reasoningTokens: undefined,
+        },
+      },
       metadata: {
         vertex: {
           cacheCreationInputTokens: 300,

packages/opencode/test/session/llm-native.test.ts

@@ -1,262 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { LLMClient, RequestExecutor } from "@opencode-ai/llm/route"
-import { jsonSchema, tool, type ModelMessage } from "ai"
-import { Effect } from "effect"
-import { LLMNative } from "@/session/llm-native"
-import type { Provider } from "@/provider/provider"
-import { ModelID, ProviderID } from "@/provider/schema"
-
-const baseModel: Provider.Model = {
-  id: ModelID.make("gpt-5-mini"),
-  providerID: ProviderID.make("openai"),
-  api: {
-    id: "gpt-5-mini",
-    url: "https://api.openai.com/v1",
-    npm: "@ai-sdk/openai",
-  },
-  name: "GPT-5 Mini",
-  capabilities: {
-    temperature: true,
-    reasoning: true,
-    attachment: true,
-    toolcall: true,
-    input: {
-      text: true,
-      audio: false,
-      image: true,
-      video: false,
-      pdf: false,
-    },
-    output: {
-      text: true,
-      audio: false,
-      image: false,
-      video: false,
-      pdf: false,
-    },
-    interleaved: false,
-  },
-  cost: {
-    input: 0,
-    output: 0,
-    cache: {
-      read: 0,
-      write: 0,
-    },
-  },
-  limit: {
-    context: 128_000,
-    input: 128_000,
-    output: 32_000,
-  },
-  status: "active",
-  options: {},
-  headers: {
-    "x-model": "model-header",
-  },
-  release_date: "2026-01-01",
-}
-
-describe("session.llm-native.request", () => {
-  test("maps normalized stream inputs to a native LLM request", () => {
-    const messages: ModelMessage[] = [
-      {
-        role: "system",
-        content: "system from messages",
-      },
-      {
-        role: "user",
-        content: [
-          { type: "text", text: "hello", providerOptions: { openai: { cacheControl: { type: "ephemeral" } } } },
-          { type: "file", mediaType: "image/png", filename: "img.png", data: "data:image/png;base64,Zm9v" },
-        ],
-      },
-      {
-        role: "assistant",
-        content: [
-          { type: "reasoning", text: "thinking", providerOptions: { openai: { encryptedContent: "secret" } } },
-          { type: "text", text: "I'll run it" },
-          {
-            type: "tool-call",
-            toolCallId: "call-1",
-            toolName: "bash",
-            input: { command: "ls" },
-            providerOptions: { openai: { itemId: "item-1" } },
-          },
-        ],
-      },
-      {
-        role: "tool",
-        content: [
-          {
-            type: "tool-result",
-            toolCallId: "call-1",
-            toolName: "bash",
-            output: { type: "text", value: "ok" },
-            providerOptions: { openai: { outputId: "output-1" } },
-          },
-        ],
-      },
-    ]
-
-    const request = LLMNative.request({
-      model: baseModel,
-      system: ["agent system"],
-      messages,
-      tools: {
-        bash: tool({
-          description: "Run a shell command",
-          inputSchema: jsonSchema({
-            type: "object",
-            properties: {
-              command: { type: "string" },
-            },
-            required: ["command"],
-          }),
-        }),
-      },
-      toolChoice: "required",
-      temperature: 0.2,
-      topP: 0.9,
-      topK: 40,
-      maxOutputTokens: 1024,
-      providerOptions: { openai: { store: false } },
-      headers: { "x-request": "request-header" },
-    })
-
-    expect(request.model).toMatchObject({
-      id: "gpt-5-mini",
-      provider: "openai",
-      route: "openai-responses",
-      baseURL: "https://api.openai.com/v1",
-      headers: {
-        "x-model": "model-header",
-        "x-request": "request-header",
-      },
-      limits: {
-        context: 128_000,
-        output: 32_000,
-      },
-    })
-    expect(request.system).toEqual([
-      { type: "text", text: "agent system" },
-      { type: "text", text: "system from messages" },
-    ])
-    expect(request.generation).toMatchObject({
-      temperature: 0.2,
-      topP: 0.9,
-      topK: 40,
-      maxTokens: 1024,
-    })
-    expect(request.providerOptions).toEqual({ openai: { store: false } })
-    expect(request.toolChoice).toMatchObject({ type: "required" })
-    expect(request.tools).toMatchObject([
-      {
-        name: "bash",
-        description: "Run a shell command",
-        inputSchema: {
-          type: "object",
-          properties: {
-            command: { type: "string" },
-          },
-          required: ["command"],
-        },
-      },
-    ])
-    expect(request.messages).toMatchObject([
-      {
-        role: "user",
-        content: [
-          { type: "text", text: "hello", providerMetadata: { openai: { cacheControl: { type: "ephemeral" } } } },
-          { type: "media", mediaType: "image/png", filename: "img.png", data: "data:image/png;base64,Zm9v" },
-        ],
-      },
-      {
-        role: "assistant",
-        content: [
-          { type: "reasoning", text: "thinking", providerMetadata: { openai: { encryptedContent: "secret" } } },
-          { type: "text", text: "I'll run it" },
-          {
-            type: "tool-call",
-            id: "call-1",
-            name: "bash",
-            input: { command: "ls" },
-            providerMetadata: { openai: { itemId: "item-1" } },
-          },
-        ],
-      },
-      {
-        role: "tool",
-        content: [
-          {
-            type: "tool-result",
-            id: "call-1",
-            name: "bash",
-            result: { type: "text", value: "ok" },
-            providerMetadata: { openai: { outputId: "output-1" } },
-          },
-        ],
-      },
-    ])
-  })
-
-  test("selects native routes from existing provider packages", () => {
-    expect(
-      LLMNative.model({ ...baseModel, api: { ...baseModel.api, url: "", npm: "@ai-sdk/anthropic" } }),
-    ).toMatchObject({
-      route: "anthropic-messages",
-      baseURL: "https://api.anthropic.com/v1",
-    })
-    expect(LLMNative.model({ ...baseModel, api: { ...baseModel.api, url: "", npm: "@ai-sdk/google" } })).toMatchObject({
-      route: "gemini",
-      baseURL: "https://generativelanguage.googleapis.com/v1beta",
-    })
-    expect(
-      LLMNative.model({ ...baseModel, api: { ...baseModel.api, npm: "@ai-sdk/openai-compatible" } }),
-    ).toMatchObject({
-      route: "openai-compatible-chat",
-      baseURL: "https://api.openai.com/v1",
-    })
-    expect(
-      LLMNative.model({ ...baseModel, api: { ...baseModel.api, url: "", npm: "@openrouter/ai-sdk-provider" } }),
-    ).toMatchObject({
-      route: "openrouter",
-      baseURL: "https://openrouter.ai/api/v1",
-    })
-  })
-
-  test("fails fast for unsupported provider packages", () => {
-    expect(() =>
-      LLMNative.request({
-        model: { ...baseModel, api: { ...baseModel.api, npm: "unknown-provider" } },
-        messages: [],
-      }),
-    ).toThrow("Native LLM request adapter does not support provider package unknown-provider")
-  })
-
-  test("compiles through the native OpenAI Responses route", async () => {
-    const prepared = await Effect.runPromise(
-      LLMClient.prepare(
-        LLMNative.request({
-          model: baseModel,
-          messages: [{ role: "user", content: "hello" }],
-          providerOptions: { openai: { store: false } },
-          maxOutputTokens: 512,
-          headers: { "x-request": "request-header" },
-        }),
-      ).pipe(Effect.provide(LLMClient.layer), Effect.provide(RequestExecutor.defaultLayer)),
-    )
-
-    expect(prepared).toMatchObject({
-      route: "openai-responses",
-      protocol: "openai-responses",
-      body: {
-        model: "gpt-5-mini",
-        input: [{ role: "user", content: [{ type: "input_text", text: "hello" }] }],
-        max_output_tokens: 512,
-        store: false,
-        stream: true,
-      },
-    })
-  })
-})

packages/opencode/test/session/llm.test.ts

@@ -1,19 +1,15 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test"
 import path from "path"
 import { tool, type ModelMessage } from "ai"
-import { Cause, Effect, Exit, Layer, Stream } from "effect"
-import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { Cause, Effect, Exit, Stream } from "effect"
 import z from "zod"
-import { attach, makeRuntime } from "../../src/effect/run-service"
+import { makeRuntime } from "../../src/effect/run-service"
 import { LLM } from "../../src/session/llm"
-import { LLMClient, RequestExecutor } from "@opencode-ai/llm/route"
+import { Instance } from "../../src/project/instance"
 import { WithInstance } from "../../src/project/with-instance"
-import { Auth } from "@/auth"
-import { Config } from "@/config/config"
 import { Provider } from "@/provider/provider"
 import { ProviderTransform } from "@/provider/transform"
 import { ModelsDev } from "@/provider/models"
-import { Plugin } from "@/plugin"
 import { ProviderID, ModelID } from "../../src/provider/schema"
 import { Filesystem } from "@/util/filesystem"
 import { tmpdir } from "../fixture/fixture"
@@ -22,29 +18,6 @@ import { MessageV2 } from "../../src/session/message-v2"
 import { SessionID, MessageID } from "../../src/session/schema"
 import { AppRuntime } from "../../src/effect/app-runtime"
 
-const openAIConfig = (model: ModelsDev.Provider["models"][string], baseURL: string): Partial<Config.Info> => {
-  const { experimental: _experimental, ...configModel } = model
-  type ConfigModel = NonNullable<NonNullable<Config.Info["provider"]>[string]["models"]>[string]
-  return {
-    enabled_providers: ["openai"],
-    provider: {
-      openai: {
-        name: "OpenAI",
-        env: ["OPENAI_API_KEY"],
-        npm: "@ai-sdk/openai",
-        api: "https://api.openai.com/v1",
-        models: {
-          [model.id]: JSON.parse(JSON.stringify(configModel)) as ConfigModel,
-        },
-        options: {
-          apiKey: "test-openai-key",
-          baseURL,
-        },
-      },
-    },
-  }
-}
-
 async function getModel(providerID: ProviderID, modelID: ModelID) {
   return AppRuntime.runPromise(
     Effect.gen(function* () {
@@ -60,22 +33,6 @@ async function drain(input: LLM.StreamInput) {
   return llm.runPromise((svc) => svc.stream(input).pipe(Stream.runDrain))
 }
 
-async function drainWith(layer: Layer.Layer<LLM.Service>, input: LLM.StreamInput) {
-  return Effect.runPromise(
-    attach(LLM.Service.use((svc) => svc.stream(input).pipe(Stream.runDrain))).pipe(Effect.provide(layer)),
-  )
-}
-
-function llmLayerWithExecutor(executor: Layer.Layer<RequestExecutor.Service>) {
-  return LLM.layer.pipe(
-    Layer.provide(Auth.defaultLayer),
-    Layer.provide(Config.defaultLayer),
-    Layer.provide(Provider.defaultLayer),
-    Layer.provide(Plugin.defaultLayer),
-    Layer.provide(LLMClient.layer.pipe(Layer.provide(executor))),
-  )
-}
-
 describe("session.llm.hasToolCalls", () => {
   test("returns false for empty messages array", () => {
     expect(LLM.hasToolCalls([])).toBe(false)
@@ -624,18 +581,6 @@ describe("session.llm.stream", () => {
           service_tier: null,
         },
       },
-      {
-        type: "response.output_item.added",
-        output_index: 0,
-        item: { type: "message", id: "item-1", status: "in_progress", role: "assistant", content: [] },
-      },
-      {
-        type: "response.content_part.added",
-        item_id: "item-1",
-        output_index: 0,
-        content_index: 0,
-        part: { type: "output_text", text: "", annotations: [] },
-      },
       {
         type: "response.output_text.delta",
         item_id: "item-1",
@@ -658,7 +603,32 @@ describe("session.llm.stream", () => {
     ]
     const request = waitRequest("/responses", createEventResponse(responseChunks, true))
 
-    await using tmp = await tmpdir({ config: openAIConfig(model, `${server.url.origin}/v1`) })
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(
+          path.join(dir, "opencode.json"),
+          JSON.stringify({
+            $schema: "https://opencode.ai/config.json",
+            enabled_providers: ["openai"],
+            provider: {
+              openai: {
+                name: "OpenAI",
+                env: ["OPENAI_API_KEY"],
+                npm: "@ai-sdk/openai",
+                api: "https://api.openai.com/v1",
+                models: {
+                  [model.id]: model,
+                },
+                options: {
+                  apiKey: "test-openai-key",
+                  baseURL: `${server.url.origin}/v1`,
+                },
+              },
+            },
+          }),
+        )
+      },
+    })
 
     await WithInstance.provide({
       directory: tmp.path,
@@ -706,333 +676,6 @@ describe("session.llm.stream", () => {
     })
   })
 
-  test("streams OpenAI through native runtime when opted in", async () => {
-    const server = state.server
-    if (!server) {
-      throw new Error("Server not initialized")
-    }
-
-    const source = await loadFixture("openai", "gpt-5.2")
-    const model = source.model
-    const chunks = [
-      {
-        type: "response.created",
-        response: {
-          id: "resp-native",
-        },
-      },
-      {
-        type: "response.output_item.added",
-        item: { type: "message", id: "item-native", status: "in_progress" },
-      },
-      {
-        type: "response.output_text.delta",
-        item_id: "item-native",
-        delta: "Hello native",
-      },
-      {
-        type: "response.completed",
-        response: {
-          incomplete_details: null,
-          usage: {
-            input_tokens: 1,
-            input_tokens_details: null,
-            output_tokens: 1,
-            output_tokens_details: null,
-          },
-        },
-      },
-    ]
-    const request = waitRequest("/responses", createEventResponse(chunks, true))
-
-    await using tmp = await tmpdir({ config: openAIConfig(model, `${server.url.origin}/v1`) })
-
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const previous = process.env.OPENCODE_LLM_RUNTIME
-        process.env.OPENCODE_LLM_RUNTIME = "native"
-        try {
-          const resolved = await getModel(ProviderID.openai, ModelID.make(model.id))
-          const sessionID = SessionID.make("session-test-native")
-          const agent = {
-            name: "test",
-            mode: "primary",
-            options: {},
-            permission: [{ permission: "*", pattern: "*", action: "allow" }],
-            temperature: 0.2,
-          } satisfies Agent.Info
-
-          await drain({
-            user: {
-              id: MessageID.make("msg_user-native"),
-              sessionID,
-              role: "user",
-              time: { created: Date.now() },
-              agent: agent.name,
-              model: { providerID: ProviderID.make("openai"), modelID: resolved.id, variant: "high" },
-            } satisfies MessageV2.User,
-            sessionID,
-            model: resolved,
-            agent,
-            system: ["You are a helpful assistant."],
-            messages: [{ role: "user", content: "Hello" }],
-            tools: {},
-          })
-        } finally {
-          if (previous === undefined) delete process.env.OPENCODE_LLM_RUNTIME
-          else process.env.OPENCODE_LLM_RUNTIME = previous
-        }
-
-        const capture = await request
-        expect(capture.url.pathname.endsWith("/responses")).toBe(true)
-        expect(capture.headers.get("Authorization")).toBe("Bearer test-openai-key")
-        expect(capture.body.model).toBe(model.id)
-        expect(capture.body.stream).toBe(true)
-        expect((capture.body.reasoning as { effort?: string } | undefined)?.effort).toBe("high")
-        expect(JSON.stringify(capture.body.input)).toContain("You are a helpful assistant.")
-        expect(capture.body.input).toContainEqual({ role: "user", content: [{ type: "input_text", text: "Hello" }] })
-      },
-    })
-  })
-
-  test("uses injected native request executor for tool calls", async () => {
-    const source = await loadFixture("openai", "gpt-5.2")
-    const model = source.model
-    const chunks = [
-      {
-        type: "response.output_item.added",
-        item: { type: "function_call", id: "item-injected-tool", call_id: "call-injected-tool", name: "lookup" },
-      },
-      {
-        type: "response.function_call_arguments.delta",
-        item_id: "item-injected-tool",
-        delta: '{"query":"weather"}',
-      },
-      {
-        type: "response.output_item.done",
-        item: {
-          type: "function_call",
-          id: "item-injected-tool",
-          call_id: "call-injected-tool",
-          name: "lookup",
-          arguments: '{"query":"weather"}',
-        },
-      },
-      {
-        type: "response.completed",
-        response: { incomplete_details: null, usage: { input_tokens: 1, output_tokens: 1 } },
-      },
-    ]
-    let captured: Record<string, unknown> | undefined
-    let executed: unknown
-    const executor = Layer.succeed(
-      RequestExecutor.Service,
-      RequestExecutor.Service.of({
-        execute: (request) =>
-          Effect.gen(function* () {
-            const web = yield* HttpClientRequest.toWeb(request).pipe(Effect.orDie)
-            captured = (yield* Effect.promise(() => web.json())) as Record<string, unknown>
-            return HttpClientResponse.fromWeb(request, createEventResponse(chunks, true))
-          }),
-      }),
-    )
-
-    await using tmp = await tmpdir({ config: openAIConfig(model, "https://injected-openai.test/v1") })
-
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const previous = process.env.OPENCODE_LLM_RUNTIME
-        process.env.OPENCODE_LLM_RUNTIME = "native"
-        try {
-          const resolved = await getModel(ProviderID.openai, ModelID.make(model.id))
-          const sessionID = SessionID.make("session-test-native-injected-tool")
-          const agent = {
-            name: "test",
-            mode: "primary",
-            options: {},
-            permission: [{ permission: "*", pattern: "*", action: "allow" }],
-          } satisfies Agent.Info
-
-          await drainWith(llmLayerWithExecutor(executor), {
-            user: {
-              id: MessageID.make("msg_user-native-injected-tool"),
-              sessionID,
-              role: "user",
-              time: { created: Date.now() },
-              agent: agent.name,
-              model: { providerID: ProviderID.make("openai"), modelID: resolved.id },
-            } satisfies MessageV2.User,
-            sessionID,
-            model: resolved,
-            agent,
-            system: [],
-            messages: [{ role: "user", content: "Use lookup" }],
-            tools: {
-              lookup: tool({
-                description: "Lookup data",
-                inputSchema: z.object({ query: z.string() }),
-                execute: async (args, options) => {
-                  executed = { args, toolCallId: options.toolCallId }
-                  return { output: "looked up" }
-                },
-              }),
-            },
-          })
-        } finally {
-          if (previous === undefined) delete process.env.OPENCODE_LLM_RUNTIME
-          else process.env.OPENCODE_LLM_RUNTIME = previous
-        }
-
-        expect(captured?.model).toBe(model.id)
-        expect(captured?.tools).toEqual([
-          {
-            type: "function",
-            name: "lookup",
-            description: "Lookup data",
-            parameters: {
-              type: "object",
-              properties: { query: { type: "string" } },
-              required: ["query"],
-              additionalProperties: false,
-              $schema: "http://json-schema.org/draft-07/schema#",
-            },
-          },
-        ])
-        expect(executed).toEqual({ args: { query: "weather" }, toolCallId: "call-injected-tool" })
-      },
-    })
-  })
-
-  test("executes OpenAI tool calls through native runtime", async () => {
-    const server = state.server
-    if (!server) {
-      throw new Error("Server not initialized")
-    }
-
-    const source = await loadFixture("openai", "gpt-5.2")
-    const model = source.model
-    const chunks = [
-      {
-        type: "response.output_item.added",
-        item: { type: "function_call", id: "item-native-tool", call_id: "call-native-tool", name: "lookup" },
-      },
-      {
-        type: "response.function_call_arguments.delta",
-        item_id: "item-native-tool",
-        delta: '{"query":"weather"}',
-      },
-      {
-        type: "response.output_item.done",
-        item: {
-          type: "function_call",
-          id: "item-native-tool",
-          call_id: "call-native-tool",
-          name: "lookup",
-          arguments: '{"query":"weather"}',
-        },
-      },
-      {
-        type: "response.completed",
-        response: { incomplete_details: null, usage: { input_tokens: 1, output_tokens: 1 } },
-      },
-    ]
-    const request = waitRequest("/responses", createEventResponse(chunks, true))
-    let executed: unknown
-
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(
-          path.join(dir, "opencode.json"),
-          JSON.stringify({
-            $schema: "https://opencode.ai/config.json",
-            enabled_providers: ["openai"],
-            provider: {
-              openai: {
-                name: "OpenAI",
-                env: ["OPENAI_API_KEY"],
-                npm: "@ai-sdk/openai",
-                api: "https://api.openai.com/v1",
-                models: {
-                  [model.id]: model,
-                },
-                options: {
-                  apiKey: "test-openai-key",
-                  baseURL: `${server.url.origin}/v1`,
-                },
-              },
-            },
-          }),
-        )
-      },
-    })
-
-    await WithInstance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const previous = process.env.OPENCODE_LLM_RUNTIME
-        process.env.OPENCODE_LLM_RUNTIME = "native"
-        try {
-          const resolved = await getModel(ProviderID.openai, ModelID.make(model.id))
-          const sessionID = SessionID.make("session-test-native-tool")
-          const agent = {
-            name: "test",
-            mode: "primary",
-            options: {},
-            permission: [{ permission: "*", pattern: "*", action: "allow" }],
-          } satisfies Agent.Info
-
-          await drain({
-            user: {
-              id: MessageID.make("msg_user-native-tool"),
-              sessionID,
-              role: "user",
-              time: { created: Date.now() },
-              agent: agent.name,
-              model: { providerID: ProviderID.make("openai"), modelID: resolved.id },
-            } satisfies MessageV2.User,
-            sessionID,
-            model: resolved,
-            agent,
-            system: [],
-            messages: [{ role: "user", content: "Use lookup" }],
-            tools: {
-              lookup: tool({
-                description: "Lookup data",
-                inputSchema: z.object({ query: z.string() }),
-                execute: async (args, options) => {
-                  executed = { args, toolCallId: options.toolCallId }
-                  return { output: "looked up" }
-                },
-              }),
-            },
-          })
-        } finally {
-          if (previous === undefined) delete process.env.OPENCODE_LLM_RUNTIME
-          else process.env.OPENCODE_LLM_RUNTIME = previous
-        }
-
-        const capture = await request
-        expect(capture.body.tools).toEqual([
-          {
-            type: "function",
-            name: "lookup",
-            description: "Lookup data",
-            parameters: {
-              type: "object",
-              properties: { query: { type: "string" } },
-              required: ["query"],
-              additionalProperties: false,
-              $schema: "http://json-schema.org/draft-07/schema#",
-            },
-          },
-        ])
-        expect(executed).toEqual({ args: { query: "weather" }, toolCallId: "call-native-tool" })
-      },
-    })
-  })
-
   test("accepts user image attachments as data URLs for OpenAI models", async () => {
     const server = state.server
     if (!server) {
@@ -1051,18 +694,6 @@ describe("session.llm.stream", () => {
           service_tier: null,
         },
       },
-      {
-        type: "response.output_item.added",
-        output_index: 0,
-        item: { type: "message", id: "item-data-url", status: "in_progress", role: "assistant", content: [] },
-      },
-      {
-        type: "response.content_part.added",
-        item_id: "item-data-url",
-        output_index: 0,
-        content_index: 0,
-        part: { type: "output_text", text: "", annotations: [] },
-      },
       {
         type: "response.output_text.delta",
         item_id: "item-data-url",

packages/opencode/test/session/session.test.ts

@@ -1,186 +1,174 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
+import { describe, expect } from "bun:test"
+import { Deferred, Effect, Exit, Layer } from "effect"
 import { Session as SessionNs } from "@/session/session"
-import { Bus } from "../../src/bus"
+import { GlobalBus, type GlobalEvent } from "../../src/bus/global"
 import * as Log from "@opencode-ai/core/util/log"
-import { Instance } from "../../src/project/instance"
-import { WithInstance } from "../../src/project/with-instance"
+import { Flag } from "@opencode-ai/core/flag/flag"
 import { MessageV2 } from "../../src/session/message-v2"
 import { MessageID, PartID, type SessionID } from "../../src/session/schema"
-import { AppRuntime } from "../../src/effect/app-runtime"
-import { tmpdir } from "../fixture/fixture"
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+import { provideInstance, tmpdirScoped } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
 
-const projectRoot = path.join(__dirname, "../..")
 void Log.init({ print: false })
 
-function create(input?: SessionNs.CreateInput) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.create(input)))
-}
+const it = testEffect(Layer.mergeAll(SessionNs.defaultLayer, CrossSpawnSpawner.defaultLayer))
 
-function get(id: SessionID) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.get(id)))
-}
+const awaitDeferred = <T>(deferred: Deferred.Deferred<T>, message: string) =>
+  Effect.race(
+    Deferred.await(deferred),
+    Effect.sleep("2 seconds").pipe(Effect.flatMap(() => Effect.fail(new Error(message)))),
+  )
 
-function remove(id: SessionID) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.remove(id)))
-}
+const remove = (id: SessionID) => SessionNs.Service.use((svc) => svc.remove(id))
 
-function updateMessage<T extends MessageV2.Info>(msg: T) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.updateMessage(msg)))
-}
-
-function updatePart<T extends MessageV2.Part>(part: T) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.updatePart(part)))
+const subscribeGlobal = (type: string, callback: (event: NonNullable<GlobalEvent["payload"]>) => void) => {
+  const listener = (event: GlobalEvent) => {
+    if (event.payload?.type === type) callback(event.payload)
+  }
+  GlobalBus.on("event", listener)
+  return () => GlobalBus.off("event", listener)
 }
 
 describe("session.created event", () => {
-  test("should emit session.created event when session is created", async () => {
-    await WithInstance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        let eventReceived = false
-        let receivedInfo: SessionNs.Info | undefined
+  it.instance("should emit session.created event when session is created", () =>
+    Effect.gen(function* () {
+      const session = yield* SessionNs.Service
+      const received = yield* Deferred.make<SessionNs.Info>()
 
-        const unsub = Bus.subscribe(SessionNs.Event.Created, (event) => {
-          eventReceived = true
-          receivedInfo = event.properties.info as SessionNs.Info
-        })
+      const unsub = subscribeGlobal(SessionNs.Event.Created.type, (event) => {
+        Deferred.doneUnsafe(received, Effect.succeed(event.properties.info as SessionNs.Info))
+      })
+      yield* Effect.addFinalizer(() => Effect.sync(unsub))
 
-        const info = await create({})
-        await new Promise((resolve) => setTimeout(resolve, 100))
-        unsub()
+      const info = yield* session.create({})
+      const receivedInfo = yield* awaitDeferred(received, "timed out waiting for session.created")
 
-        expect(eventReceived).toBe(true)
-        expect(receivedInfo).toBeDefined()
-        expect(receivedInfo?.id).toBe(info.id)
-        expect(receivedInfo?.projectID).toBe(info.projectID)
-        expect(receivedInfo?.directory).toBe(info.directory)
-        expect(receivedInfo?.path).toBe(info.path)
-        expect(receivedInfo?.title).toBe(info.title)
+      expect(receivedInfo.id).toBe(info.id)
+      expect(receivedInfo.projectID).toBe(info.projectID)
+      expect(receivedInfo.directory).toBe(info.directory)
+      expect(receivedInfo.path).toBe(info.path)
+      expect(receivedInfo.title).toBe(info.title)
 
-        await remove(info.id)
-      },
-    })
-  })
+      yield* session.remove(info.id)
+    }),
+  )
 
-  test("session.created event should be emitted before session.updated", async () => {
-    await WithInstance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        const events: string[] = []
+  it.instance("session.created event should be emitted before session.updated", () =>
+    Effect.gen(function* () {
+      if (Flag.OPENCODE_EXPERIMENTAL_WORKSPACES) return
 
-        const unsubCreated = Bus.subscribe(SessionNs.Event.Created, () => {
-          events.push("created")
-        })
+      const session = yield* SessionNs.Service
+      const events: string[] = []
+      const received = yield* Deferred.make<string[]>()
+      const push = (event: string) => {
+        events.push(event)
+        if (events.includes("created") && events.includes("updated")) {
+          Deferred.doneUnsafe(received, Effect.succeed(events))
+        }
+      }
 
-        const unsubUpdated = Bus.subscribe(SessionNs.Event.Updated, () => {
-          events.push("updated")
-        })
+      const unsubCreated = subscribeGlobal(SessionNs.Event.Created.type, () => {
+        push("created")
+      })
+      yield* Effect.addFinalizer(() => Effect.sync(unsubCreated))
 
-        const info = await create({})
-        await new Promise((resolve) => setTimeout(resolve, 100))
-        unsubCreated()
-        unsubUpdated()
+      const unsubUpdated = subscribeGlobal(SessionNs.Event.Updated.type, () => {
+        push("updated")
+      })
+      yield* Effect.addFinalizer(() => Effect.sync(unsubUpdated))
 
-        expect(events).toContain("created")
-        expect(events).toContain("updated")
-        expect(events.indexOf("created")).toBeLessThan(events.indexOf("updated"))
+      const info = yield* session.create({})
+      const receivedEvents = yield* awaitDeferred(received, "timed out waiting for session created/updated events")
 
-        await remove(info.id)
-      },
-    })
-  })
+      expect(receivedEvents).toContain("created")
+      expect(receivedEvents).toContain("updated")
+      expect(receivedEvents.indexOf("created")).toBeLessThan(receivedEvents.indexOf("updated"))
+
+      yield* session.remove(info.id)
+    }),
+  )
 })
 
 describe("step-finish token propagation via Bus event", () => {
-  test(
+  it.instance(
     "non-zero tokens propagate through PartUpdated event",
-    async () => {
-      await WithInstance.provide({
-        directory: projectRoot,
-        fn: async () => {
-          const info = await create({})
+    () =>
+      Effect.gen(function* () {
+        const session = yield* SessionNs.Service
+        const info = yield* session.create({})
 
-          const messageID = MessageID.ascending()
-          await updateMessage({
-            id: messageID,
-            sessionID: info.id,
-            role: "user",
-            time: { created: Date.now() },
-            agent: "user",
-            model: { providerID: "test", modelID: "test" },
-            tools: {},
-            mode: "",
-          } as unknown as MessageV2.Info)
+        const messageID = MessageID.ascending()
+        yield* session.updateMessage({
+          id: messageID,
+          sessionID: info.id,
+          role: "user",
+          time: { created: Date.now() },
+          agent: "user",
+          model: { providerID: "test", modelID: "test" },
+          tools: {},
+          mode: "",
+        } as unknown as MessageV2.Info)
 
-          // Bus subscribers receive readonly Schema.Type payloads; `MessageV2.Part`
-          // is the mutable domain type. Cast bridges the two — safe because the
-          // test only reads the value afterwards.
-          let received: MessageV2.Part | undefined
-          const unsub = Bus.subscribe(MessageV2.Event.PartUpdated, (event) => {
-            received = event.properties.part as MessageV2.Part
-          })
+        // Bus subscribers receive readonly Schema.Type payloads; `MessageV2.Part`
+        // is the mutable domain type. Cast bridges the two — safe because the
+        // test only reads the value afterwards.
+        const received = yield* Deferred.make<MessageV2.Part>()
+        const unsub = subscribeGlobal(MessageV2.Event.PartUpdated.type, (event) => {
+          Deferred.doneUnsafe(received, Effect.succeed(event.properties.part as MessageV2.Part))
+        })
+        yield* Effect.addFinalizer(() => Effect.sync(unsub))
 
-          const tokens = {
-            total: 1500,
-            input: 500,
-            output: 800,
-            reasoning: 200,
-            cache: { read: 100, write: 50 },
-          }
+        const tokens = {
+          total: 1500,
+          input: 500,
+          output: 800,
+          reasoning: 200,
+          cache: { read: 100, write: 50 },
+        }
 
-          const partInput = {
-            id: PartID.ascending(),
-            messageID,
-            sessionID: info.id,
-            type: "step-finish" as const,
-            reason: "stop",
-            cost: 0.005,
-            tokens,
-          }
+        const partInput = {
+          id: PartID.ascending(),
+          messageID,
+          sessionID: info.id,
+          type: "step-finish" as const,
+          reason: "stop",
+          cost: 0.005,
+          tokens,
+        }
 
-          await updatePart(partInput)
-          await new Promise((resolve) => setTimeout(resolve, 100))
+        yield* session.updatePart(partInput)
+        const receivedPart = yield* awaitDeferred(received, "timed out waiting for message.part.updated")
 
-          expect(received).toBeDefined()
-          expect(received!.type).toBe("step-finish")
-          const finish = received as MessageV2.StepFinishPart
-          expect(finish.tokens.input).toBe(500)
-          expect(finish.tokens.output).toBe(800)
-          expect(finish.tokens.reasoning).toBe(200)
-          expect(finish.tokens.total).toBe(1500)
-          expect(finish.tokens.cache.read).toBe(100)
-          expect(finish.tokens.cache.write).toBe(50)
-          expect(finish.cost).toBe(0.005)
-          expect(received).not.toBe(partInput)
+        expect(receivedPart.type).toBe("step-finish")
+        const finish = receivedPart as MessageV2.StepFinishPart
+        expect(finish.tokens.input).toBe(500)
+        expect(finish.tokens.output).toBe(800)
+        expect(finish.tokens.reasoning).toBe(200)
+        expect(finish.tokens.total).toBe(1500)
+        expect(finish.tokens.cache.read).toBe(100)
+        expect(finish.tokens.cache.write).toBe(50)
+        expect(finish.cost).toBe(0.005)
+        expect(receivedPart).not.toBe(partInput)
 
-          unsub()
-          await remove(info.id)
-        },
-      })
-    },
+        yield* session.remove(info.id)
+      }),
     { timeout: 30000 },
   )
 })
 
 describe("Session", () => {
-  test("remove works without an instance", async () => {
-    await using tmp = await tmpdir({ git: true })
+  it.live("remove works without an instance", () =>
+    Effect.gen(function* () {
+      const session = yield* SessionNs.Service
+      const dir = yield* tmpdirScoped({ git: true })
+      const info = yield* provideInstance(dir)(session.create({ title: "remove-without-instance" }))
 
-    const info = await WithInstance.provide({
-      directory: tmp.path,
-      fn: () => create({ title: "remove-without-instance" }),
-    })
+      const removeExit = yield* remove(info.id).pipe(Effect.exit)
+      expect(Exit.isSuccess(removeExit)).toBe(true)
 
-    await expect(async () => {
-      await remove(info.id)
-    }).not.toThrow()
-
-    let missing = false
-    await get(info.id).catch(() => {
-      missing = true
-    })
-
-    expect(missing).toBe(true)
-  })
+      const getExit = yield* session.get(info.id).pipe(Effect.exit)
+      expect(Exit.isFailure(getExit)).toBe(true)
+    }),
+  )
 })

packages/opencode/test/skill/discovery.test.ts

@@ -1,10 +1,11 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test"
+import { describe, expect, beforeAll, afterAll } from "bun:test"
 import { Effect } from "effect"
 import { Discovery } from "../../src/skill/discovery"
 import { Global } from "@opencode-ai/core/global"
 import { Filesystem } from "@/util/filesystem"
 import { rm } from "fs/promises"
 import path from "path"
+import { testEffect } from "../lib/effect"
 
 let CLOUDFLARE_SKILLS_URL: string
 let server: ReturnType<typeof Bun.serve>
@@ -12,6 +13,7 @@ let downloadCount = 0
 
 const fixturePath = path.join(import.meta.dir, "../fixture/skills")
 const cacheDir = path.join(Global.Path.cache, "skills")
+const it = testEffect(Discovery.defaultLayer)
 
 beforeAll(async () => {
   await rm(cacheDir, { recursive: true, force: true })
@@ -47,70 +49,85 @@ afterAll(async () => {
 })
 
 describe("Discovery.pull", () => {
-  const pull = (url: string) =>
-    Effect.runPromise(Discovery.Service.use((s) => s.pull(url)).pipe(Effect.provide(Discovery.defaultLayer)))
-
-  test("downloads skills from cloudflare url", async () => {
-    const dirs = await pull(CLOUDFLARE_SKILLS_URL)
-    expect(dirs.length).toBeGreaterThan(0)
-    for (const dir of dirs) {
-      expect(dir).toStartWith(cacheDir)
-      const md = path.join(dir, "SKILL.md")
-      expect(await Filesystem.exists(md)).toBe(true)
-    }
+  const pull = Effect.fn("DiscoveryTest.pull")(function* (url: string) {
+    return yield* Discovery.Service.use((s) => s.pull(url))
   })
 
-  test("url without trailing slash works", async () => {
-    const dirs = await pull(CLOUDFLARE_SKILLS_URL.replace(/\/$/, ""))
-    expect(dirs.length).toBeGreaterThan(0)
-    for (const dir of dirs) {
-      const md = path.join(dir, "SKILL.md")
-      expect(await Filesystem.exists(md)).toBe(true)
-    }
-  })
+  it.live("downloads skills from cloudflare url", () =>
+    Effect.gen(function* () {
+      const dirs = yield* pull(CLOUDFLARE_SKILLS_URL)
+      expect(dirs.length).toBeGreaterThan(0)
+      for (const dir of dirs) {
+        expect(dir).toStartWith(cacheDir)
+        const md = path.join(dir, "SKILL.md")
+        expect(yield* Effect.promise(() => Filesystem.exists(md))).toBe(true)
+      }
+    }),
+  )
 
-  test("returns empty array for invalid url", async () => {
-    const dirs = await pull(`http://localhost:${server.port}/invalid-url/`)
-    expect(dirs).toEqual([])
-  })
+  it.live("url without trailing slash works", () =>
+    Effect.gen(function* () {
+      const dirs = yield* pull(CLOUDFLARE_SKILLS_URL.replace(/\/$/, ""))
+      expect(dirs.length).toBeGreaterThan(0)
+      for (const dir of dirs) {
+        const md = path.join(dir, "SKILL.md")
+        expect(yield* Effect.promise(() => Filesystem.exists(md))).toBe(true)
+      }
+    }),
+  )
 
-  test("returns empty array for non-json response", async () => {
-    // any url not explicitly handled in server returns 404 text "Not Found"
-    const dirs = await pull(`http://localhost:${server.port}/some-other-path/`)
-    expect(dirs).toEqual([])
-  })
+  it.live("returns empty array for invalid url", () =>
+    Effect.gen(function* () {
+      const dirs = yield* pull(`http://localhost:${server.port}/invalid-url/`)
+      expect(dirs).toEqual([])
+    }),
+  )
 
-  test("downloads reference files alongside SKILL.md", async () => {
-    const dirs = await pull(CLOUDFLARE_SKILLS_URL)
-    // find a skill dir that should have reference files (e.g. agents-sdk)
-    const agentsSdk = dirs.find((d) => d.endsWith(path.sep + "agents-sdk"))
-    expect(agentsSdk).toBeDefined()
-    if (agentsSdk) {
-      const refs = path.join(agentsSdk, "references")
-      expect(await Filesystem.exists(path.join(agentsSdk, "SKILL.md"))).toBe(true)
-      // agents-sdk has reference files per the index
-      const refDir = await Array.fromAsync(new Bun.Glob("**/*.md").scan({ cwd: refs, onlyFiles: true }))
-      expect(refDir.length).toBeGreaterThan(0)
-    }
-  })
+  it.live("returns empty array for non-json response", () =>
+    Effect.gen(function* () {
+      // any url not explicitly handled in server returns 404 text "Not Found"
+      const dirs = yield* pull(`http://localhost:${server.port}/some-other-path/`)
+      expect(dirs).toEqual([])
+    }),
+  )
 
-  test("caches downloaded files on second pull", async () => {
-    // clear dir and downloadCount
-    await rm(cacheDir, { recursive: true, force: true })
-    downloadCount = 0
+  it.live("downloads reference files alongside SKILL.md", () =>
+    Effect.gen(function* () {
+      const dirs = yield* pull(CLOUDFLARE_SKILLS_URL)
+      // find a skill dir that should have reference files (e.g. agents-sdk)
+      const agentsSdk = dirs.find((d) => d.endsWith(path.sep + "agents-sdk"))
+      expect(agentsSdk).toBeDefined()
+      if (agentsSdk) {
+        const refs = path.join(agentsSdk, "references")
+        expect(yield* Effect.promise(() => Filesystem.exists(path.join(agentsSdk, "SKILL.md")))).toBe(true)
+        // agents-sdk has reference files per the index
+        const refDir = yield* Effect.promise(() =>
+          Array.fromAsync(new Bun.Glob("**/*.md").scan({ cwd: refs, onlyFiles: true })),
+        )
+        expect(refDir.length).toBeGreaterThan(0)
+      }
+    }),
+  )
 
-    // first pull to populate cache
-    const first = await pull(CLOUDFLARE_SKILLS_URL)
-    expect(first.length).toBeGreaterThan(0)
-    const firstCount = downloadCount
-    expect(firstCount).toBeGreaterThan(0)
+  it.live("caches downloaded files on second pull", () =>
+    Effect.gen(function* () {
+      // clear dir and downloadCount
+      yield* Effect.promise(() => rm(cacheDir, { recursive: true, force: true }))
+      downloadCount = 0
 
-    // second pull should return same results from cache
-    const second = await pull(CLOUDFLARE_SKILLS_URL)
-    expect(second.length).toBe(first.length)
-    expect(second.sort()).toEqual(first.sort())
+      // first pull to populate cache
+      const first = yield* pull(CLOUDFLARE_SKILLS_URL)
+      expect(first.length).toBeGreaterThan(0)
+      const firstCount = downloadCount
+      expect(firstCount).toBeGreaterThan(0)
 
-    // second pull should NOT increment download count
-    expect(downloadCount).toBe(firstCount)
-  })
+      // second pull should return same results from cache
+      const second = yield* pull(CLOUDFLARE_SKILLS_URL)
+      expect(second.length).toBe(first.length)
+      expect(second.sort()).toEqual(first.sort())
+
+      // second pull should NOT increment download count
+      expect(downloadCount).toBe(firstCount)
+    }),
+  )
 })

packages/opencode/test/tool/apply_patch.test.ts

@@ -1,20 +1,19 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import path from "path"
 import * as fs from "fs/promises"
-import { Effect, ManagedRuntime, Layer } from "effect"
+import { Cause, Effect, Exit, Layer } from "effect"
 import { ApplyPatchTool } from "../../src/tool/apply_patch"
-import { Instance } from "../../src/project/instance"
-import { WithInstance } from "../../src/project/with-instance"
 import { LSP } from "@/lsp/lsp"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { Format } from "../../src/format"
 import { Agent } from "../../src/agent/agent"
 import { Bus } from "../../src/bus"
 import { Truncate } from "@/tool/truncate"
-import { tmpdir } from "../fixture/fixture"
+import { TestInstance } from "../fixture/fixture"
 import { SessionID, MessageID } from "../../src/session/schema"
+import { testEffect } from "../lib/effect"
 
-const runtime = ManagedRuntime.make(
+const it = testEffect(
   Layer.mergeAll(
     LSP.defaultLayer,
     AppFileSystem.defaultLayer,
@@ -58,11 +57,11 @@ type ToolCtx = typeof baseCtx & {
   ask: (input: AskInput) => Effect.Effect<void>
 }
 
-const execute = async (params: { patchText: string }, ctx: ToolCtx) => {
-  const info = await runtime.runPromise(ApplyPatchTool)
-  const tool = await runtime.runPromise(info.init())
-  return Effect.runPromise(tool.execute(params, ctx))
-}
+const execute = Effect.fn("ApplyPatchToolTest.execute")(function* (params: { patchText: string }, ctx: ToolCtx) {
+  const info = yield* ApplyPatchTool
+  const tool = yield* info.init()
+  return yield* tool.execute(params, ctx)
+})
 
 const makeCtx = () => {
   const calls: AskInput[] = []
@@ -77,39 +76,56 @@ const makeCtx = () => {
   return { ctx, calls }
 }
 
+const readText = (filepath: string) => Effect.promise(() => fs.readFile(filepath, "utf-8"))
+const writeText = (filepath: string, content: string) => Effect.promise(() => fs.writeFile(filepath, content, "utf-8"))
+const makeDir = (dir: string) => Effect.promise(() => fs.mkdir(dir, { recursive: true }))
+
+const expectFailure = <A, E, R>(effect: Effect.Effect<A, E, R>, message?: string) =>
+  Effect.gen(function* () {
+    const exit = yield* Effect.exit(effect)
+    expect(Exit.isFailure(exit)).toBe(true)
+    if (Exit.isFailure(exit) && message) expect(Cause.pretty(exit.cause)).toContain(message)
+  })
+
+const expectReadFailure = (filepath: string) => expectFailure(readText(filepath))
+
 describe("tool.apply_patch freeform", () => {
-  test("requires patchText", async () => {
-    const { ctx } = makeCtx()
-    await expect(execute({ patchText: "" }, ctx)).rejects.toThrow("patchText is required")
-  })
+  it.live("requires patchText", () =>
+    Effect.gen(function* () {
+      const { ctx } = makeCtx()
+      yield* expectFailure(execute({ patchText: "" }, ctx), "patchText is required")
+    }),
+  )
 
-  test("rejects invalid patch format", async () => {
-    const { ctx } = makeCtx()
-    await expect(execute({ patchText: "invalid patch" }, ctx)).rejects.toThrow("apply_patch verification failed")
-  })
+  it.live("rejects invalid patch format", () =>
+    Effect.gen(function* () {
+      const { ctx } = makeCtx()
+      yield* expectFailure(execute({ patchText: "invalid patch" }, ctx), "apply_patch verification failed")
+    }),
+  )
 
-  test("rejects empty patch", async () => {
-    const { ctx } = makeCtx()
-    const emptyPatch = "*** Begin Patch\n*** End Patch"
-    await expect(execute({ patchText: emptyPatch }, ctx)).rejects.toThrow("patch rejected: empty patch")
-  })
+  it.live("rejects empty patch", () =>
+    Effect.gen(function* () {
+      const { ctx } = makeCtx()
+      yield* expectFailure(execute({ patchText: "*** Begin Patch\n*** End Patch" }, ctx), "patch rejected: empty patch")
+    }),
+  )
 
-  test("applies add/update/delete in one patch", async () => {
-    await using fixture = await tmpdir({ git: true })
-    const { ctx, calls } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const modifyPath = path.join(fixture.path, "modify.txt")
-        const deletePath = path.join(fixture.path, "delete.txt")
-        await fs.writeFile(modifyPath, "line1\nline2\n", "utf-8")
-        await fs.writeFile(deletePath, "obsolete\n", "utf-8")
+  it.instance(
+    "applies add/update/delete in one patch",
+    () =>
+      Effect.gen(function* () {
+        const test = yield* TestInstance
+        const { ctx, calls } = makeCtx()
+        const modifyPath = path.join(test.directory, "modify.txt")
+        const deletePath = path.join(test.directory, "delete.txt")
+        yield* writeText(modifyPath, "line1\nline2\n")
+        yield* writeText(deletePath, "obsolete\n")
 
         const patchText =
           "*** Begin Patch\n*** Add File: nested/new.txt\n+created\n*** Delete File: delete.txt\n*** Update File: modify.txt\n@@\n-line2\n+changed\n*** End Patch"
 
-        const result = await execute({ patchText }, ctx)
+        const result = yield* execute({ patchText }, ctx)
 
         expect(result.title).toContain("Success. Updated the following files")
         expect(result.output).toContain("Success. Updated the following files")
@@ -129,38 +145,34 @@ describe("tool.apply_patch freeform", () => {
         expect(permissionCall.metadata.files.map((f) => f.type).sort()).toEqual(["add", "delete", "update"])
 
         const addFile = permissionCall.metadata.files.find((f) => f.type === "add")
-        expect(addFile).toBeDefined()
-        expect(addFile!.relativePath).toBe("nested/new.txt")
-        expect(addFile!.patch).toContain("+created")
+        expect(addFile?.relativePath).toBe("nested/new.txt")
+        expect(addFile?.patch).toContain("+created")
 
         const updateFile = permissionCall.metadata.files.find((f) => f.type === "update")
-        expect(updateFile).toBeDefined()
-        expect(updateFile!.patch).toContain("-line2")
-        expect(updateFile!.patch).toContain("+changed")
+        expect(updateFile?.patch).toContain("-line2")
+        expect(updateFile?.patch).toContain("+changed")
 
-        const added = await fs.readFile(path.join(fixture.path, "nested", "new.txt"), "utf-8")
-        expect(added).toBe("created\n")
-        expect(await fs.readFile(modifyPath, "utf-8")).toBe("line1\nchanged\n")
-        await expect(fs.readFile(deletePath, "utf-8")).rejects.toThrow()
-      },
-    })
-  })
+        expect(yield* readText(path.join(test.directory, "nested", "new.txt"))).toBe("created\n")
+        expect(yield* readText(modifyPath)).toBe("line1\nchanged\n")
+        yield* expectReadFailure(deletePath)
+      }),
+    { git: true },
+  )
 
-  test("permission metadata includes move file info", async () => {
-    await using fixture = await tmpdir({ git: true })
-    const { ctx, calls } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const original = path.join(fixture.path, "old", "name.txt")
-        await fs.mkdir(path.dirname(original), { recursive: true })
-        await fs.writeFile(original, "old content\n", "utf-8")
+  it.instance(
+    "permission metadata includes move file info",
+    () =>
+      Effect.gen(function* () {
+        const test = yield* TestInstance
+        const { ctx, calls } = makeCtx()
+        const original = path.join(test.directory, "old", "name.txt")
+        yield* makeDir(path.dirname(original))
+        yield* writeText(original, "old content\n")
 
         const patchText =
           "*** Begin Patch\n*** Update File: old/name.txt\n*** Move to: renamed/dir/name.txt\n@@\n-old content\n+new content\n*** End Patch"
 
-        await execute({ patchText }, ctx)
+        yield* execute({ patchText }, ctx)
 
         expect(calls.length).toBe(1)
         const permissionCall = calls[0]
@@ -169,447 +181,353 @@ describe("tool.apply_patch freeform", () => {
         const moveFile = permissionCall.metadata.files[0]
         expect(moveFile.type).toBe("move")
         expect(moveFile.relativePath).toBe("renamed/dir/name.txt")
-        expect(moveFile.movePath).toBe(path.join(fixture.path, "renamed/dir/name.txt"))
+        expect(moveFile.movePath).toBe(path.join(test.directory, "renamed/dir/name.txt"))
         expect(moveFile.patch).toContain("-old content")
         expect(moveFile.patch).toContain("+new content")
-      },
-    })
-  })
-
-  test("applies multiple hunks to one file", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "multi.txt")
-        await fs.writeFile(target, "line1\nline2\nline3\nline4\n", "utf-8")
-
-        const patchText =
-          "*** Begin Patch\n*** Update File: multi.txt\n@@\n-line2\n+changed2\n@@\n-line4\n+changed4\n*** End Patch"
-
-        await execute({ patchText }, ctx)
-
-        expect(await fs.readFile(target, "utf-8")).toBe("line1\nchanged2\nline3\nchanged4\n")
-      },
-    })
-  })
-
-  test("does not invent a first-line diff for BOM files", async () => {
-    await using fixture = await tmpdir()
-    const { ctx, calls } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const bom = String.fromCharCode(0xfeff)
-        const target = path.join(fixture.path, "example.cs")
-        await fs.writeFile(target, `${bom}using System;\n\nclass Test {}\n`, "utf-8")
-
-        const patchText =
-          "*** Begin Patch\n*** Update File: example.cs\n@@\n class Test {}\n+class Next {}\n*** End Patch"
-
-        await execute({ patchText }, ctx)
-
-        expect(calls.length).toBe(1)
-        const shown = calls[0].metadata.files[0]?.patch ?? ""
-        expect(shown).not.toContain(bom)
-        expect(shown).not.toContain("-using System;")
-        expect(shown).not.toContain("+using System;")
-
-        const content = await fs.readFile(target, "utf-8")
-        expect(content.charCodeAt(0)).toBe(0xfeff)
-        expect(content.slice(1)).toBe("using System;\n\nclass Test {}\nclass Next {}\n")
-      },
-    })
-  })
-
-  test("inserts lines with insert-only hunk", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "insert_only.txt")
-        await fs.writeFile(target, "alpha\nomega\n", "utf-8")
-
-        const patchText = "*** Begin Patch\n*** Update File: insert_only.txt\n@@\n alpha\n+beta\n omega\n*** End Patch"
-
-        await execute({ patchText }, ctx)
-
-        expect(await fs.readFile(target, "utf-8")).toBe("alpha\nbeta\nomega\n")
-      },
-    })
-  })
-
-  test("appends trailing newline on update", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "no_newline.txt")
-        await fs.writeFile(target, "no newline at end", "utf-8")
-
-        const patchText =
-          "*** Begin Patch\n*** Update File: no_newline.txt\n@@\n-no newline at end\n+first line\n+second line\n*** End Patch"
-
-        await execute({ patchText }, ctx)
-
-        const contents = await fs.readFile(target, "utf-8")
-        expect(contents.endsWith("\n")).toBe(true)
-        expect(contents).toBe("first line\nsecond line\n")
-      },
-    })
-  })
-
-  test("moves file to a new directory", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const original = path.join(fixture.path, "old", "name.txt")
-        await fs.mkdir(path.dirname(original), { recursive: true })
-        await fs.writeFile(original, "old content\n", "utf-8")
-
-        const patchText =
-          "*** Begin Patch\n*** Update File: old/name.txt\n*** Move to: renamed/dir/name.txt\n@@\n-old content\n+new content\n*** End Patch"
-
-        await execute({ patchText }, ctx)
-
-        const moved = path.join(fixture.path, "renamed", "dir", "name.txt")
-        await expect(fs.readFile(original, "utf-8")).rejects.toThrow()
-        expect(await fs.readFile(moved, "utf-8")).toBe("new content\n")
-      },
-    })
-  })
-
-  test("moves file overwriting existing destination", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const original = path.join(fixture.path, "old", "name.txt")
-        const destination = path.join(fixture.path, "renamed", "dir", "name.txt")
-        await fs.mkdir(path.dirname(original), { recursive: true })
-        await fs.mkdir(path.dirname(destination), { recursive: true })
-        await fs.writeFile(original, "from\n", "utf-8")
-        await fs.writeFile(destination, "existing\n", "utf-8")
-
-        const patchText =
-          "*** Begin Patch\n*** Update File: old/name.txt\n*** Move to: renamed/dir/name.txt\n@@\n-from\n+new\n*** End Patch"
-
-        await execute({ patchText }, ctx)
-
-        await expect(fs.readFile(original, "utf-8")).rejects.toThrow()
-        expect(await fs.readFile(destination, "utf-8")).toBe("new\n")
-      },
-    })
-  })
-
-  test("adds file overwriting existing file", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "duplicate.txt")
-        await fs.writeFile(target, "old content\n", "utf-8")
-
-        const patchText = "*** Begin Patch\n*** Add File: duplicate.txt\n+new content\n*** End Patch"
-
-        await execute({ patchText }, ctx)
-        expect(await fs.readFile(target, "utf-8")).toBe("new content\n")
-      },
-    })
-  })
-
-  test("rejects update when target file is missing", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const patchText = "*** Begin Patch\n*** Update File: missing.txt\n@@\n-nope\n+better\n*** End Patch"
-
-        await expect(execute({ patchText }, ctx)).rejects.toThrow(
-          "apply_patch verification failed: Failed to read file to update",
-        )
-      },
-    })
-  })
-
-  test("rejects delete when file is missing", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const patchText = "*** Begin Patch\n*** Delete File: missing.txt\n*** End Patch"
-
-        await expect(execute({ patchText }, ctx)).rejects.toThrow()
-      },
-    })
-  })
-
-  test("rejects delete when target is a directory", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const dirPath = path.join(fixture.path, "dir")
-        await fs.mkdir(dirPath)
-
-        const patchText = "*** Begin Patch\n*** Delete File: dir\n*** End Patch"
-
-        await expect(execute({ patchText }, ctx)).rejects.toThrow()
-      },
-    })
-  })
-
-  test("rejects invalid hunk header", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const patchText = "*** Begin Patch\n*** Frobnicate File: foo\n*** End Patch"
-
-        await expect(execute({ patchText }, ctx)).rejects.toThrow("apply_patch verification failed")
-      },
-    })
-  })
-
-  test("rejects update with missing context", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "modify.txt")
-        await fs.writeFile(target, "line1\nline2\n", "utf-8")
-
-        const patchText = "*** Begin Patch\n*** Update File: modify.txt\n@@\n-missing\n+changed\n*** End Patch"
-
-        await expect(execute({ patchText }, ctx)).rejects.toThrow("apply_patch verification failed")
-        expect(await fs.readFile(target, "utf-8")).toBe("line1\nline2\n")
-      },
-    })
-  })
-
-  test("verification failure leaves no side effects", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const patchText =
-          "*** Begin Patch\n*** Add File: created.txt\n+hello\n*** Update File: missing.txt\n@@\n-old\n+new\n*** End Patch"
-
-        await expect(execute({ patchText }, ctx)).rejects.toThrow()
-
-        const createdPath = path.join(fixture.path, "created.txt")
-        await expect(fs.readFile(createdPath, "utf-8")).rejects.toThrow()
-      },
-    })
-  })
-
-  test("supports end of file anchor", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "tail.txt")
-        await fs.writeFile(target, "alpha\nlast\n", "utf-8")
-
-        const patchText = "*** Begin Patch\n*** Update File: tail.txt\n@@\n-last\n+end\n*** End of File\n*** End Patch"
-
-        await execute({ patchText }, ctx)
-        expect(await fs.readFile(target, "utf-8")).toBe("alpha\nend\n")
-      },
-    })
-  })
-
-  test("rejects missing second chunk context", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "two_chunks.txt")
-        await fs.writeFile(target, "a\nb\nc\nd\n", "utf-8")
-
-        const patchText = "*** Begin Patch\n*** Update File: two_chunks.txt\n@@\n-b\n+B\n\n-d\n+D\n*** End Patch"
-
-        await expect(execute({ patchText }, ctx)).rejects.toThrow()
-        expect(await fs.readFile(target, "utf-8")).toBe("a\nb\nc\nd\n")
-      },
-    })
-  })
-
-  test("disambiguates change context with @@ header", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "multi_ctx.txt")
-        await fs.writeFile(target, "fn a\nx=10\ny=2\nfn b\nx=10\ny=20\n", "utf-8")
-
-        const patchText = "*** Begin Patch\n*** Update File: multi_ctx.txt\n@@ fn b\n-x=10\n+x=11\n*** End Patch"
-
-        await execute({ patchText }, ctx)
-        expect(await fs.readFile(target, "utf-8")).toBe("fn a\nx=10\ny=2\nfn b\nx=11\ny=20\n")
-      },
-    })
-  })
-
-  test("EOF anchor matches from end of file first", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "eof_anchor.txt")
-        // File has duplicate "marker" lines - one in middle, one at end
-        await fs.writeFile(target, "start\nmarker\nmiddle\nmarker\nend\n", "utf-8")
-
-        // With EOF anchor, should match the LAST "marker" line, not the first
-        const patchText =
-          "*** Begin Patch\n*** Update File: eof_anchor.txt\n@@\n-marker\n-end\n+marker-changed\n+end\n*** End of File\n*** End Patch"
-
-        await execute({ patchText }, ctx)
-        // First marker unchanged, second marker changed
-        expect(await fs.readFile(target, "utf-8")).toBe("start\nmarker\nmiddle\nmarker-changed\nend\n")
-      },
-    })
-  })
-
-  test("parses heredoc-wrapped patch", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const patchText = `cat <<'EOF'
+      }),
+    { git: true },
+  )
+
+  it.instance("applies multiple hunks to one file", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "multi.txt")
+      yield* writeText(target, "line1\nline2\nline3\nline4\n")
+
+      const patchText =
+        "*** Begin Patch\n*** Update File: multi.txt\n@@\n-line2\n+changed2\n@@\n-line4\n+changed4\n*** End Patch"
+
+      yield* execute({ patchText }, ctx)
+
+      expect(yield* readText(target)).toBe("line1\nchanged2\nline3\nchanged4\n")
+    }),
+  )
+
+  it.instance("does not invent a first-line diff for BOM files", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx, calls } = makeCtx()
+      const bom = String.fromCharCode(0xfeff)
+      const target = path.join(test.directory, "example.cs")
+      yield* writeText(target, `${bom}using System;\n\nclass Test {}\n`)
+
+      const patchText =
+        "*** Begin Patch\n*** Update File: example.cs\n@@\n class Test {}\n+class Next {}\n*** End Patch"
+
+      yield* execute({ patchText }, ctx)
+
+      expect(calls.length).toBe(1)
+      const shown = calls[0].metadata.files[0]?.patch ?? ""
+      expect(shown).not.toContain(bom)
+      expect(shown).not.toContain("-using System;")
+      expect(shown).not.toContain("+using System;")
+
+      const content = yield* readText(target)
+      expect(content.charCodeAt(0)).toBe(0xfeff)
+      expect(content.slice(1)).toBe("using System;\n\nclass Test {}\nclass Next {}\n")
+    }),
+  )
+
+  it.instance("inserts lines with insert-only hunk", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "insert_only.txt")
+      yield* writeText(target, "alpha\nomega\n")
+
+      const patchText = "*** Begin Patch\n*** Update File: insert_only.txt\n@@\n alpha\n+beta\n omega\n*** End Patch"
+
+      yield* execute({ patchText }, ctx)
+
+      expect(yield* readText(target)).toBe("alpha\nbeta\nomega\n")
+    }),
+  )
+
+  it.instance("appends trailing newline on update", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "no_newline.txt")
+      yield* writeText(target, "no newline at end")
+
+      const patchText =
+        "*** Begin Patch\n*** Update File: no_newline.txt\n@@\n-no newline at end\n+first line\n+second line\n*** End Patch"
+
+      yield* execute({ patchText }, ctx)
+
+      const contents = yield* readText(target)
+      expect(contents.endsWith("\n")).toBe(true)
+      expect(contents).toBe("first line\nsecond line\n")
+    }),
+  )
+
+  it.instance("moves file to a new directory", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const original = path.join(test.directory, "old", "name.txt")
+      yield* makeDir(path.dirname(original))
+      yield* writeText(original, "old content\n")
+
+      const patchText =
+        "*** Begin Patch\n*** Update File: old/name.txt\n*** Move to: renamed/dir/name.txt\n@@\n-old content\n+new content\n*** End Patch"
+
+      yield* execute({ patchText }, ctx)
+
+      const moved = path.join(test.directory, "renamed", "dir", "name.txt")
+      yield* expectReadFailure(original)
+      expect(yield* readText(moved)).toBe("new content\n")
+    }),
+  )
+
+  it.instance("moves file overwriting existing destination", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const original = path.join(test.directory, "old", "name.txt")
+      const destination = path.join(test.directory, "renamed", "dir", "name.txt")
+      yield* makeDir(path.dirname(original))
+      yield* makeDir(path.dirname(destination))
+      yield* writeText(original, "from\n")
+      yield* writeText(destination, "existing\n")
+
+      const patchText =
+        "*** Begin Patch\n*** Update File: old/name.txt\n*** Move to: renamed/dir/name.txt\n@@\n-from\n+new\n*** End Patch"
+
+      yield* execute({ patchText }, ctx)
+
+      yield* expectReadFailure(original)
+      expect(yield* readText(destination)).toBe("new\n")
+    }),
+  )
+
+  it.instance("adds file overwriting existing file", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "duplicate.txt")
+      yield* writeText(target, "old content\n")
+
+      const patchText = "*** Begin Patch\n*** Add File: duplicate.txt\n+new content\n*** End Patch"
+
+      yield* execute({ patchText }, ctx)
+      expect(yield* readText(target)).toBe("new content\n")
+    }),
+  )
+
+  it.instance("rejects update when target file is missing", () =>
+    Effect.gen(function* () {
+      const { ctx } = makeCtx()
+      const patchText = "*** Begin Patch\n*** Update File: missing.txt\n@@\n-nope\n+better\n*** End Patch"
+
+      yield* expectFailure(
+        execute({ patchText }, ctx),
+        "apply_patch verification failed: Failed to read file to update",
+      )
+    }),
+  )
+
+  it.instance("rejects delete when file is missing", () =>
+    Effect.gen(function* () {
+      const { ctx } = makeCtx()
+      const patchText = "*** Begin Patch\n*** Delete File: missing.txt\n*** End Patch"
+
+      yield* expectFailure(execute({ patchText }, ctx))
+    }),
+  )
+
+  it.instance("rejects delete when target is a directory", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const dirPath = path.join(test.directory, "dir")
+      yield* makeDir(dirPath)
+
+      const patchText = "*** Begin Patch\n*** Delete File: dir\n*** End Patch"
+
+      yield* expectFailure(execute({ patchText }, ctx))
+    }),
+  )
+
+  it.instance("rejects invalid hunk header", () =>
+    Effect.gen(function* () {
+      const { ctx } = makeCtx()
+      const patchText = "*** Begin Patch\n*** Frobnicate File: foo\n*** End Patch"
+
+      yield* expectFailure(execute({ patchText }, ctx), "apply_patch verification failed")
+    }),
+  )
+
+  it.instance("rejects update with missing context", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "modify.txt")
+      yield* writeText(target, "line1\nline2\n")
+
+      const patchText = "*** Begin Patch\n*** Update File: modify.txt\n@@\n-missing\n+changed\n*** End Patch"
+
+      yield* expectFailure(execute({ patchText }, ctx), "apply_patch verification failed")
+      expect(yield* readText(target)).toBe("line1\nline2\n")
+    }),
+  )
+
+  it.instance("verification failure leaves no side effects", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const patchText =
+        "*** Begin Patch\n*** Add File: created.txt\n+hello\n*** Update File: missing.txt\n@@\n-old\n+new\n*** End Patch"
+
+      yield* expectFailure(execute({ patchText }, ctx))
+      yield* expectReadFailure(path.join(test.directory, "created.txt"))
+    }),
+  )
+
+  it.instance("supports end of file anchor", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "tail.txt")
+      yield* writeText(target, "alpha\nlast\n")
+
+      const patchText = "*** Begin Patch\n*** Update File: tail.txt\n@@\n-last\n+end\n*** End of File\n*** End Patch"
+
+      yield* execute({ patchText }, ctx)
+      expect(yield* readText(target)).toBe("alpha\nend\n")
+    }),
+  )
+
+  it.instance("rejects missing second chunk context", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "two_chunks.txt")
+      yield* writeText(target, "a\nb\nc\nd\n")
+
+      const patchText = "*** Begin Patch\n*** Update File: two_chunks.txt\n@@\n-b\n+B\n\n-d\n+D\n*** End Patch"
+
+      yield* expectFailure(execute({ patchText }, ctx))
+      expect(yield* readText(target)).toBe("a\nb\nc\nd\n")
+    }),
+  )
+
+  it.instance("disambiguates change context with @@ header", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "multi_ctx.txt")
+      yield* writeText(target, "fn a\nx=10\ny=2\nfn b\nx=10\ny=20\n")
+
+      const patchText = "*** Begin Patch\n*** Update File: multi_ctx.txt\n@@ fn b\n-x=10\n+x=11\n*** End Patch"
+
+      yield* execute({ patchText }, ctx)
+      expect(yield* readText(target)).toBe("fn a\nx=10\ny=2\nfn b\nx=11\ny=20\n")
+    }),
+  )
+
+  it.instance("EOF anchor matches from end of file first", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "eof_anchor.txt")
+      // File has duplicate "marker" lines - one in middle, one at end
+      yield* writeText(target, "start\nmarker\nmiddle\nmarker\nend\n")
+
+      // With EOF anchor, should match the LAST "marker" line, not the first
+      const patchText =
+        "*** Begin Patch\n*** Update File: eof_anchor.txt\n@@\n-marker\n-end\n+marker-changed\n+end\n*** End of File\n*** End Patch"
+
+      yield* execute({ patchText }, ctx)
+      // First marker unchanged, second marker changed
+      expect(yield* readText(target)).toBe("start\nmarker\nmiddle\nmarker-changed\nend\n")
+    }),
+  )
+
+  it.instance("parses heredoc-wrapped patch", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const patchText = `cat <<'EOF'
 *** Begin Patch
 *** Add File: heredoc_test.txt
 +heredoc content
 *** End Patch
 EOF`
 
-        await execute({ patchText }, ctx)
-        const content = await fs.readFile(path.join(fixture.path, "heredoc_test.txt"), "utf-8")
-        expect(content).toBe("heredoc content\n")
-      },
-    })
-  })
+      yield* execute({ patchText }, ctx)
+      expect(yield* readText(path.join(test.directory, "heredoc_test.txt"))).toBe("heredoc content\n")
+    }),
+  )
 
-  test("parses heredoc-wrapped patch without cat", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const patchText = `<<EOF
+  it.instance("parses heredoc-wrapped patch without cat", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const patchText = `<<EOF
 *** Begin Patch
 *** Add File: heredoc_no_cat.txt
 +no cat prefix
 *** End Patch
 EOF`
 
-        await execute({ patchText }, ctx)
-        const content = await fs.readFile(path.join(fixture.path, "heredoc_no_cat.txt"), "utf-8")
-        expect(content).toBe("no cat prefix\n")
-      },
-    })
-  })
+      yield* execute({ patchText }, ctx)
+      expect(yield* readText(path.join(test.directory, "heredoc_no_cat.txt"))).toBe("no cat prefix\n")
+    }),
+  )
 
-  test("matches with trailing whitespace differences", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
+  it.instance("matches with trailing whitespace differences", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "trailing_ws.txt")
+      // File has trailing spaces on some lines
+      yield* writeText(target, "line1  \nline2\nline3   \n")
 
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "trailing_ws.txt")
-        // File has trailing spaces on some lines
-        await fs.writeFile(target, "line1  \nline2\nline3   \n", "utf-8")
+      // Patch doesn't have trailing spaces - should still match via rstrip pass
+      const patchText = "*** Begin Patch\n*** Update File: trailing_ws.txt\n@@\n-line2\n+changed\n*** End Patch"
 
-        // Patch doesn't have trailing spaces - should still match via rstrip pass
-        const patchText = "*** Begin Patch\n*** Update File: trailing_ws.txt\n@@\n-line2\n+changed\n*** End Patch"
+      yield* execute({ patchText }, ctx)
+      expect(yield* readText(target)).toBe("line1  \nchanged\nline3   \n")
+    }),
+  )
 
-        await execute({ patchText }, ctx)
-        expect(await fs.readFile(target, "utf-8")).toBe("line1  \nchanged\nline3   \n")
-      },
-    })
-  })
+  it.instance("matches with leading whitespace differences", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "leading_ws.txt")
+      // File has leading spaces
+      yield* writeText(target, "  line1\nline2\n  line3\n")
 
-  test("matches with leading whitespace differences", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
+      // Patch without leading spaces - should match via trim pass
+      const patchText = "*** Begin Patch\n*** Update File: leading_ws.txt\n@@\n-line2\n+changed\n*** End Patch"
 
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "leading_ws.txt")
-        // File has leading spaces
-        await fs.writeFile(target, "  line1\nline2\n  line3\n", "utf-8")
+      yield* execute({ patchText }, ctx)
+      expect(yield* readText(target)).toBe("  line1\nchanged\n  line3\n")
+    }),
+  )
 
-        // Patch without leading spaces - should match via trim pass
-        const patchText = "*** Begin Patch\n*** Update File: leading_ws.txt\n@@\n-line2\n+changed\n*** End Patch"
+  it.instance("matches with Unicode punctuation differences", () =>
+    Effect.gen(function* () {
+      const test = yield* TestInstance
+      const { ctx } = makeCtx()
+      const target = path.join(test.directory, "unicode.txt")
+      // File has fancy Unicode quotes (U+201C, U+201D) and em-dash (U+2014)
+      const leftQuote = "\u201C"
+      const rightQuote = "\u201D"
+      const emDash = "\u2014"
+      yield* writeText(target, `He said ${leftQuote}hello${rightQuote}\nsome${emDash}dash\nend\n`)
 
-        await execute({ patchText }, ctx)
-        expect(await fs.readFile(target, "utf-8")).toBe("  line1\nchanged\n  line3\n")
-      },
-    })
-  })
+      // Patch uses ASCII equivalents - should match via normalized pass
+      // The replacement uses ASCII quotes from the patch (not preserving Unicode)
+      const patchText =
+        '*** Begin Patch\n*** Update File: unicode.txt\n@@\n-He said "hello"\n+He said "hi"\n*** End Patch'
 
-  test("matches with Unicode punctuation differences", async () => {
-    await using fixture = await tmpdir()
-    const { ctx } = makeCtx()
-
-    await WithInstance.provide({
-      directory: fixture.path,
-      fn: async () => {
-        const target = path.join(fixture.path, "unicode.txt")
-        // File has fancy Unicode quotes (U+201C, U+201D) and em-dash (U+2014)
-        const leftQuote = "\u201C"
-        const rightQuote = "\u201D"
-        const emDash = "\u2014"
-        await fs.writeFile(target, `He said ${leftQuote}hello${rightQuote}\nsome${emDash}dash\nend\n`, "utf-8")
-
-        // Patch uses ASCII equivalents - should match via normalized pass
-        // The replacement uses ASCII quotes from the patch (not preserving Unicode)
-        const patchText =
-          '*** Begin Patch\n*** Update File: unicode.txt\n@@\n-He said "hello"\n+He said "hi"\n*** End Patch'
-
-        await execute({ patchText }, ctx)
-        // Result has ASCII quotes because that's what the patch specifies
-        expect(await fs.readFile(target, "utf-8")).toBe(`He said "hi"\nsome${emDash}dash\nend\n`)
-      },
-    })
-  })
+      yield* execute({ patchText }, ctx)
+      // Result has ASCII quotes because that's what the patch specifies
+      expect(yield* readText(target)).toBe(`He said "hi"\nsome${emDash}dash\nend\n`)
+    }),
+  )
 })

packages/opencode/test/tool/edit.test.ts

@@ -1,10 +1,9 @@
-import { afterAll, afterEach, describe, test, expect } from "bun:test"
+import { afterEach, describe, expect } from "bun:test"
 import path from "path"
 import fs from "fs/promises"
-import { Cause, Deferred, Effect, Exit, Layer, ManagedRuntime } from "effect"
+import { Cause, Deferred, Effect, Exit, Fiber, Layer } from "effect"
 import { EditTool } from "../../src/tool/edit"
-import { WithInstance } from "../../src/project/with-instance"
-import { disposeAllInstances, TestInstance, tmpdir } from "../fixture/fixture"
+import { disposeAllInstances, TestInstance } from "../fixture/fixture"
 import { LSP } from "@/lsp/lsp"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { Format } from "../../src/format"
@@ -42,20 +41,6 @@ const layer = Layer.mergeAll(
 
 const it = testEffect(layer)
 
-const runtime = ManagedRuntime.make(layer)
-
-afterAll(async () => {
-  await runtime.dispose()
-})
-
-const resolve = () =>
-  runtime.runPromise(
-    Effect.gen(function* () {
-      const info = yield* EditTool
-      return yield* info.init()
-    }),
-  )
-
 const init = Effect.fn("EditToolTest.init")(function* () {
   const info = yield* EditTool
   return yield* info.init()
@@ -500,58 +485,49 @@ describe("tool.edit", () => {
   })
 
   describe("concurrent editing", () => {
-    test("preserves concurrent edits to different sections of the same file", async () => {
-      await using tmp = await tmpdir()
-      const filepath = path.join(tmp.path, "file.txt")
-      await fs.writeFile(filepath, "top = 0\nmiddle = keep\nbottom = 0\n", "utf-8")
+    it.instance("preserves concurrent edits to different sections of the same file", () =>
+      Effect.gen(function* () {
+        const test = yield* TestInstance
+        const filepath = path.join(test.directory, "file.txt")
+        yield* put(filepath, "top = 0\nmiddle = keep\nbottom = 0\n")
 
-      await WithInstance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const edit = await resolve()
-          let asks = 0
-          const firstAsk = Promise.withResolvers<void>()
-          const delayedCtx = {
-            ...ctx,
-            ask: () =>
-              Effect.gen(function* () {
-                asks++
-                if (asks !== 1) return
-                firstAsk.resolve()
-                yield* Effect.promise(() => Bun.sleep(50))
-              }),
-          }
+        const firstAsk = yield* Deferred.make<void>()
+        let asks = 0
+        const delayedCtx = {
+          ...ctx,
+          ask: () =>
+            Effect.gen(function* () {
+              asks++
+              if (asks !== 1) return
+              yield* Deferred.succeed(firstAsk, undefined)
+              yield* Effect.promise(() => Bun.sleep(50))
+            }),
+        }
 
-          const promise1 = Effect.runPromise(
-            edit.execute(
-              {
-                filePath: filepath,
-                oldString: "top = 0",
-                newString: "top = 1",
-              },
-              delayedCtx,
-            ),
-          )
+        const first = yield* run(
+          {
+            filePath: filepath,
+            oldString: "top = 0",
+            newString: "top = 1",
+          },
+          delayedCtx,
+        ).pipe(Effect.forkScoped)
 
-          await firstAsk.promise
+        yield* Deferred.await(firstAsk)
+        yield* Effect.all([
+          Fiber.join(first),
+          run(
+            {
+              filePath: filepath,
+              oldString: "bottom = 0",
+              newString: "bottom = 2",
+            },
+            delayedCtx,
+          ),
+        ])
 
-          const promise2 = Effect.runPromise(
-            edit.execute(
-              {
-                filePath: filepath,
-                oldString: "bottom = 0",
-                newString: "bottom = 2",
-              },
-              delayedCtx,
-            ),
-          )
-
-          const results = await Promise.allSettled([promise1, promise2])
-          expect(results[0]?.status).toBe("fulfilled")
-          expect(results[1]?.status).toBe("fulfilled")
-          expect(await fs.readFile(filepath, "utf-8")).toBe("top = 1\nmiddle = keep\nbottom = 2\n")
-        },
-      })
-    })
+        expect(yield* load(filepath)).toBe("top = 1\nmiddle = keep\nbottom = 2\n")
+      }),
+    )
   })
 })

packages/opencode/test/tool/external-directory.test.ts

@@ -1,14 +1,16 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import path from "path"
 import { Effect } from "effect"
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import type { Tool } from "@/tool/tool"
-import { Instance } from "../../src/project/instance"
-import { WithInstance } from "../../src/project/with-instance"
-import { assertExternalDirectory } from "../../src/tool/external-directory"
+import { assertExternalDirectoryEffect } from "../../src/tool/external-directory"
 import { Filesystem } from "@/util/filesystem"
-import { tmpdir } from "../fixture/fixture"
+import { provideInstance, TestInstance, tmpdirScoped } from "../fixture/fixture"
 import type { Permission } from "../../src/permission"
 import { SessionID, MessageID } from "../../src/session/schema"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(CrossSpawnSpawner.defaultLayer)
 
 const baseCtx: Omit<Tool.Context, "ask"> = {
   sessionID: SessionID.make("ses_test"),
@@ -36,135 +38,120 @@ function makeCtx() {
 }
 
 describe("tool.assertExternalDirectory", () => {
-  test("no-ops for empty target", async () => {
-    const { requests, ctx } = makeCtx()
+  it.live("no-ops for empty target", () =>
+    Effect.gen(function* () {
+      const { requests, ctx } = makeCtx()
 
-    await WithInstance.provide({
-      directory: "/tmp",
-      fn: async () => {
-        await assertExternalDirectory(ctx)
-      },
-    })
+      yield* assertExternalDirectoryEffect(ctx)
 
-    expect(requests.length).toBe(0)
-  })
+      expect(requests.length).toBe(0)
+    }),
+  )
 
-  test("no-ops for paths inside Instance.directory", async () => {
-    const { requests, ctx } = makeCtx()
+  it.live("no-ops for paths inside Instance.directory", () =>
+    provideInstance("/tmp/project")(
+      Effect.gen(function* () {
+        const { requests, ctx } = makeCtx()
 
-    await WithInstance.provide({
-      directory: "/tmp/project",
-      fn: async () => {
-        await assertExternalDirectory(ctx, path.join("/tmp/project", "file.txt"))
-      },
-    })
+        yield* assertExternalDirectoryEffect(ctx, path.join("/tmp/project", "file.txt"))
 
-    expect(requests.length).toBe(0)
-  })
+        expect(requests.length).toBe(0)
+      }),
+    ),
+  )
 
-  test("asks with a single canonical glob", async () => {
-    const { requests, ctx } = makeCtx()
+  it.live("asks with a single canonical glob", () =>
+    Effect.gen(function* () {
+      const { requests, ctx } = makeCtx()
 
-    const directory = "/tmp/project"
-    const target = "/tmp/outside/file.txt"
-    const expected = glob(path.join(path.dirname(target), "*"))
+      const directory = "/tmp/project"
+      const target = "/tmp/outside/file.txt"
+      const expected = glob(path.join(path.dirname(target), "*"))
 
-    await WithInstance.provide({
-      directory,
-      fn: async () => {
-        await assertExternalDirectory(ctx, target)
-      },
-    })
+      yield* provideInstance(directory)(assertExternalDirectoryEffect(ctx, target))
 
-    const req = requests.find((r) => r.permission === "external_directory")
-    expect(req).toBeDefined()
-    expect(req!.patterns).toEqual([expected])
-    expect(req!.always).toEqual([expected])
-  })
+      const req = requests.find((r) => r.permission === "external_directory")
+      expect(req).toBeDefined()
+      expect(req!.patterns).toEqual([expected])
+      expect(req!.always).toEqual([expected])
+    }),
+  )
 
-  test("uses target directory when kind=directory", async () => {
-    const { requests, ctx } = makeCtx()
+  it.live("uses target directory when kind=directory", () =>
+    Effect.gen(function* () {
+      const { requests, ctx } = makeCtx()
 
-    const directory = "/tmp/project"
-    const target = "/tmp/outside"
-    const expected = glob(path.join(target, "*"))
+      const directory = "/tmp/project"
+      const target = "/tmp/outside"
+      const expected = glob(path.join(target, "*"))
 
-    await WithInstance.provide({
-      directory,
-      fn: async () => {
-        await assertExternalDirectory(ctx, target, { kind: "directory" })
-      },
-    })
+      yield* provideInstance(directory)(assertExternalDirectoryEffect(ctx, target, { kind: "directory" }))
 
-    const req = requests.find((r) => r.permission === "external_directory")
-    expect(req).toBeDefined()
-    expect(req!.patterns).toEqual([expected])
-    expect(req!.always).toEqual([expected])
-  })
+      const req = requests.find((r) => r.permission === "external_directory")
+      expect(req).toBeDefined()
+      expect(req!.patterns).toEqual([expected])
+      expect(req!.always).toEqual([expected])
+    }),
+  )
 
-  test("skips prompting when bypass=true", async () => {
-    const { requests, ctx } = makeCtx()
+  it.live("skips prompting when bypass=true", () =>
+    provideInstance("/tmp/project")(
+      Effect.gen(function* () {
+        const { requests, ctx } = makeCtx()
 
-    await WithInstance.provide({
-      directory: "/tmp/project",
-      fn: async () => {
-        await assertExternalDirectory(ctx, "/tmp/outside/file.txt", { bypass: true })
-      },
-    })
+        yield* assertExternalDirectoryEffect(ctx, "/tmp/outside/file.txt", { bypass: true })
 
-    expect(requests.length).toBe(0)
-  })
+        expect(requests.length).toBe(0)
+      }),
+    ),
+  )
 
   if (process.platform === "win32") {
-    test("normalizes Windows path variants to one glob", async () => {
-      const { requests, ctx } = makeCtx()
+    it.instance(
+      "normalizes Windows path variants to one glob",
+      () =>
+        Effect.gen(function* () {
+          const { requests, ctx } = makeCtx()
 
-      await using outerTmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, "outside.txt"), "x")
-        },
-      })
-      await using tmp = await tmpdir({ git: true })
+          const outerTmp = yield* tmpdirScoped()
+          yield* Effect.promise(() => Bun.write(path.join(outerTmp, "outside.txt"), "x"))
 
-      const target = path.join(outerTmp.path, "outside.txt")
-      const alt = target
-        .replace(/^[A-Za-z]:/, "")
-        .replaceAll("\\", "/")
-        .toLowerCase()
+          const target = path.join(outerTmp, "outside.txt")
+          const alt = target
+            .replace(/^[A-Za-z]:/, "")
+            .replaceAll("\\", "/")
+            .toLowerCase()
 
-      await WithInstance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          await assertExternalDirectory(ctx, alt)
-        },
-      })
+          yield* assertExternalDirectoryEffect(ctx, alt)
 
-      const req = requests.find((r) => r.permission === "external_directory")
-      const expected = glob(path.join(outerTmp.path, "*"))
-      expect(req).toBeDefined()
-      expect(req!.patterns).toEqual([expected])
-      expect(req!.always).toEqual([expected])
-    })
+          const req = requests.find((r) => r.permission === "external_directory")
+          const expected = glob(path.join(outerTmp, "*"))
+          expect(req).toBeDefined()
+          expect(req!.patterns).toEqual([expected])
+          expect(req!.always).toEqual([expected])
+        }),
+      { git: true },
+    )
 
-    test("uses drive root glob for root files", async () => {
-      const { requests, ctx } = makeCtx()
+    it.instance(
+      "uses drive root glob for root files",
+      () =>
+        Effect.gen(function* () {
+          const { requests, ctx } = makeCtx()
 
-      await using tmp = await tmpdir({ git: true })
-      const root = path.parse(tmp.path).root
-      const target = path.join(root, "boot.ini")
+          const tmp = yield* TestInstance
+          const root = path.parse(tmp.directory).root
+          const target = path.join(root, "boot.ini")
 
-      await WithInstance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          await assertExternalDirectory(ctx, target)
-        },
-      })
+          yield* assertExternalDirectoryEffect(ctx, target)
 
-      const req = requests.find((r) => r.permission === "external_directory")
-      const expected = path.join(root, "*")
-      expect(req).toBeDefined()
-      expect(req!.patterns).toEqual([expected])
-      expect(req!.always).toEqual([expected])
-    })
+          const req = requests.find((r) => r.permission === "external_directory")
+          const expected = path.join(root, "*")
+          expect(req).toBeDefined()
+          expect(req!.patterns).toEqual([expected])
+          expect(req!.always).toEqual([expected])
+        }),
+      { git: true },
+    )
   }
 })

packages/opencode/test/tool/registry.test.ts

@@ -180,7 +180,7 @@ describe("tool.registry", () => {
       const promptTools = yield* registry.tools({
         providerID: ProviderID.opencode,
         modelID: ModelID.make("test"),
-        agent: yield* agents.get(yield* agents.defaultAgent()),
+        agent: yield* agents.defaultInfo(),
       })
       const promptTool = promptTools.find((tool) => tool.id === "sql")
       if (!promptTool) throw new Error("custom sql tool was not returned for prompts")

packages/opencode/test/tool/tool-define.test.ts

@@ -1,11 +1,12 @@
-import { describe, test, expect } from "bun:test"
-import { Effect, Layer, ManagedRuntime, Schema } from "effect"
+import { describe, expect } from "bun:test"
+import { Effect, Layer, Schema } from "effect"
 import { Agent } from "../../src/agent/agent"
 import { MessageID, SessionID } from "../../src/session/schema"
 import { Tool } from "@/tool/tool"
 import { Truncate } from "@/tool/truncate"
+import { testEffect } from "../lib/effect"
 
-const runtime = ManagedRuntime.make(Layer.mergeAll(Truncate.defaultLayer, Agent.defaultLayer))
+const it = testEffect(Layer.mergeAll(Truncate.defaultLayer, Agent.defaultLayer))
 
 const params = Schema.Struct({ input: Schema.String })
 
@@ -21,49 +22,53 @@ function makeTool(id: string, executeFn?: () => void) {
 }
 
 describe("Tool.define", () => {
-  test("object-defined tool does not mutate the original init object", async () => {
-    const original = makeTool("test")
-    const originalExecute = original.execute
+  it.effect("object-defined tool does not mutate the original init object", () =>
+    Effect.gen(function* () {
+      const original = makeTool("test")
+      const originalExecute = original.execute
 
-    const info = await runtime.runPromise(Tool.define("test-tool", Effect.succeed(original)))
+      const info = yield* Tool.define("test-tool", Effect.succeed(original))
 
-    await Effect.runPromise(info.init())
-    await Effect.runPromise(info.init())
-    await Effect.runPromise(info.init())
+      yield* info.init()
+      yield* info.init()
+      yield* info.init()
 
-    expect(original.execute).toBe(originalExecute)
-  })
+      expect(original.execute).toBe(originalExecute)
+    }),
+  )
 
-  test("effect-defined tool returns fresh objects and is unaffected", async () => {
-    const info = await runtime.runPromise(
-      Tool.define(
+  it.effect("effect-defined tool returns fresh objects and is unaffected", () =>
+    Effect.gen(function* () {
+      const info = yield* Tool.define(
         "test-fn-tool",
         Effect.succeed(() => Effect.succeed(makeTool("test"))),
-      ),
-    )
+      )
 
-    const first = await Effect.runPromise(info.init())
-    const second = await Effect.runPromise(info.init())
+      const first = yield* info.init()
+      const second = yield* info.init()
 
-    expect(first).not.toBe(second)
-  })
+      expect(first).not.toBe(second)
+    }),
+  )
 
-  test("object-defined tool returns distinct objects per init() call", async () => {
-    const info = await runtime.runPromise(Tool.define("test-copy", Effect.succeed(makeTool("test"))))
+  it.effect("object-defined tool returns distinct objects per init() call", () =>
+    Effect.gen(function* () {
+      const info = yield* Tool.define("test-copy", Effect.succeed(makeTool("test")))
 
-    const first = await Effect.runPromise(info.init())
-    const second = await Effect.runPromise(info.init())
+      const first = yield* info.init()
+      const second = yield* info.init()
 
-    expect(first).not.toBe(second)
-  })
+      expect(first).not.toBe(second)
+    }),
+  )
 
-  test("execute receives decoded parameters", async () => {
-    const parameters = Schema.Struct({
-      count: Schema.NumberFromString.pipe(Schema.optional, Schema.withDecodingDefaultType(Effect.succeed(5))),
-    })
-    const calls: Array<Schema.Schema.Type<typeof parameters>> = []
-    const info = await runtime.runPromise(
-      Tool.define(
+  it.effect("execute receives decoded parameters", () =>
+    Effect.gen(function* () {
+      const parameters = Schema.Struct({
+        count: Schema.NumberFromString.pipe(Schema.optional, Schema.withDecodingDefaultType(Effect.succeed(5))),
+      })
+      const calls: Array<Schema.Schema.Type<typeof parameters>> = []
+      const info = yield* Tool.define(
         "test-decoded",
         Effect.succeed({
           description: "test tool",
@@ -73,27 +78,27 @@ describe("Tool.define", () => {
             return Effect.succeed({ title: "test", output: "ok", metadata: { truncated: false } })
           },
         }),
-      ),
-    )
-    const ctx: Tool.Context = {
-      sessionID: SessionID.descending(),
-      messageID: MessageID.ascending(),
-      agent: "build",
-      abort: new AbortController().signal,
-      messages: [],
-      metadata() {
-        return Effect.void
-      },
-      ask() {
-        return Effect.void
-      },
-    }
-    const tool = await Effect.runPromise(info.init())
-    const execute = tool.execute as unknown as (args: unknown, ctx: Tool.Context) => ReturnType<typeof tool.execute>
+      )
+      const ctx: Tool.Context = {
+        sessionID: SessionID.descending(),
+        messageID: MessageID.ascending(),
+        agent: "build",
+        abort: new AbortController().signal,
+        messages: [],
+        metadata() {
+          return Effect.void
+        },
+        ask() {
+          return Effect.void
+        },
+      }
+      const tool = yield* info.init()
+      const execute = tool.execute as unknown as (args: unknown, ctx: Tool.Context) => ReturnType<typeof tool.execute>
 
-    await Effect.runPromise(execute({}, ctx))
-    await Effect.runPromise(execute({ count: "7" }, ctx))
+      yield* execute({}, ctx)
+      yield* execute({ count: "7" }, ctx)
 
-    expect(calls).toEqual([{ count: 5 }, { count: 7 }])
-  })
+      expect(calls).toEqual([{ count: 5 }, { count: 7 }])
+    }),
+  )
 })

packages/opencode/test/util/error.test.ts

@@ -1,9 +1,7 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
 import { NamedError } from "@opencode-ai/core/util/error"
 import { errorData, errorFormat, errorMessage } from "../../src/util/error"
-import { namedSchemaError } from "../../src/util/named-schema-error"
-import { UI } from "../../src/cli/ui"
+import { MessageError } from "../../src/session/message-error"
 
 describe("util.error", () => {
   test("formats native Error instances", () => {
@@ -53,17 +51,14 @@ describe("util.error", () => {
     expect(String(data.formatted)).toContain("ResolveMessage")
   })
 
-  test("named schema errors are real NamedError instances", () => {
-    const ExampleError = namedSchemaError("ExampleError", { message: Schema.String })
-    const error = new ExampleError({ message: "boom" })
+  test("schema-backed named errors are real NamedError instances", () => {
+    const error = new MessageError.AuthError({ providerID: "anthropic", message: "boom" })
 
     expect(error).toBeInstanceOf(NamedError)
-    expect(error.toObject()).toEqual({ name: "ExampleError", data: { message: "boom" } })
+    expect(error.toObject()).toEqual({ name: "ProviderAuthError", data: { providerID: "anthropic", message: "boom" } })
   })
 
-  test("void named errors accept JSON without data", () => {
-    const serialized = JSON.parse(JSON.stringify(new UI.CancelledError(undefined).toObject()))
-
-    expect(Schema.decodeUnknownOption(UI.CancelledError.Schema)(serialized)._tag).toBe("Some")
+  test("named errors without fields serialize data", () => {
+    expect(new MessageError.OutputLengthError({}).toObject()).toEqual({ name: "MessageOutputLengthError", data: {} })
   })
 })

packages/storybook/.storybook/mocks/app/context/global-sync.ts

@@ -40,3 +40,16 @@ export function useGlobalSync() {
     },
   }
 }
+
+export function useQueryOptions() {
+  return {
+    agents: (directory: string) => ({
+      queryKey: [directory, "agents"],
+      queryFn: async () => [],
+    }),
+    providers: (directory: string | null) => ({
+      queryKey: [directory, "providers"],
+      queryFn: async () => provider,
+    }),
+  }
+}