test: harden edit watcher assertions

.github/VOUCHED.td

@@ -26,7 +26,6 @@ kommander
 r44vc0rp
 rekram1-node
 -robinmordasiewicz
-simonklee
 -spider-yamet clawdbot/llm psychosis, spam pinging the team
 thdxr
 -toastythebot

packages/opencode/specs/effect-migration.md

@@ -217,7 +217,6 @@ Fully migrated (single namespace, InstanceState where needed, flattened facade):
 - [x] `SessionSummary` — `session/summary.ts`
 - [x] `SessionRevert` — `session/revert.ts`
 - [x] `Instruction` — `session/instruction.ts`
-- [x] `SystemPrompt` — `session/system.ts`
 - [x] `Provider` — `provider/provider.ts`
 - [x] `Storage` — `storage/storage.ts`
 - [x] `ShareNext` — `share/share-next.ts`
@@ -341,47 +340,3 @@ For each service, the migration is roughly:
 - `ShareNext` — migrated 2026-04-11. Swapped remaining async callers to `AppRuntime.runPromise(ShareNext.Service.use(...))`, removed the `makeRuntime(...)` facade, and kept instance bootstrap on the shared app runtime.
 - `SessionTodo` — migrated 2026-04-10. Already matched the target service shape in `session/todo.ts`: single namespace, traced Effect methods, and no `makeRuntime(...)` facade remained; checklist updated to reflect the completed migration.
 - `Storage` — migrated 2026-04-10. One production caller (`Session.diff`) and all storage.test.ts tests converted to effectful style. Facades and `makeRuntime` removed.
-- `SessionRunState` — migrated 2026-04-11. Single caller in `server/routes/session.ts` converted; facade removed.
-- `Account` — migrated 2026-04-11. Callers in `server/routes/experimental.ts` and `cli/cmd/account.ts` converted; facade removed.
-- `Instruction` — migrated 2026-04-11. Test-only callers converted; facade removed.
-- `FileTime` — migrated 2026-04-11. Test-only callers converted; facade removed.
-- `FileWatcher` — migrated 2026-04-11. Callers in `project/bootstrap.ts` and test converted; facade removed.
-- `Question` — migrated 2026-04-11. Callers in `server/routes/question.ts` and test converted; facade removed.
-- `Truncate` — migrated 2026-04-11. Caller in `tool/tool.ts` and test converted; facade removed.
-
-## Route handler effectification
-
-Route handlers should wrap their entire body in a single `AppRuntime.runPromise(Effect.gen(...))` call, yielding services from context rather than calling facades one-by-one. This eliminates multiple `runPromise` round-trips and lets handlers compose naturally.
-
-```ts
-// Before — one facade call per service
-;async (c) => {
-  await SessionRunState.assertNotBusy(id)
-  await Session.removeMessage({ sessionID: id, messageID })
-  return c.json(true)
-}
-
-// After — one Effect.gen, yield services from context
-;async (c) => {
-  await AppRuntime.runPromise(
-    Effect.gen(function* () {
-      const state = yield* SessionRunState.Service
-      const session = yield* Session.Service
-      yield* state.assertNotBusy(id)
-      yield* session.removeMessage({ sessionID: id, messageID })
-    }),
-  )
-  return c.json(true)
-}
-```
-
-When migrating, always use `{ concurrency: "unbounded" }` with `Effect.all` — route handlers should run independent service calls in parallel, not sequentially.
-
-Route files to convert (each handler that calls facades should be wrapped):
-
-- [ ] `server/routes/session.ts` — heaviest; uses Session, SessionPrompt, SessionRevert, SessionCompaction, SessionShare, SessionSummary, SessionRunState, Agent, Permission, Bus
-- [ ] `server/routes/global.ts` — uses Config, Project, Provider, Vcs, Snapshot, Agent
-- [ ] `server/routes/provider.ts` — uses Provider, Auth, Config
-- [ ] `server/routes/question.ts` — uses Question
-- [ ] `server/routes/pty.ts` — uses Pty
-- [ ] `server/routes/experimental.ts` — uses Account, ToolRegistry, Agent, MCP, Config

packages/opencode/src/agent/agent.ts

@@ -398,13 +398,11 @@ export namespace Agent {
     }),
   )
 
-  export const defaultLayer = Layer.suspend(() =>
-    layer.pipe(
-      Layer.provide(Provider.defaultLayer),
-      Layer.provide(Auth.defaultLayer),
-      Layer.provide(Config.defaultLayer),
-      Layer.provide(Skill.defaultLayer),
-    ),
+  export const defaultLayer = layer.pipe(
+    Layer.provide(Provider.defaultLayer),
+    Layer.provide(Auth.defaultLayer),
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(Skill.defaultLayer),
   )
 
   const { runPromise } = makeRuntime(Service, defaultLayer)

packages/opencode/src/command/index.ts

@@ -183,7 +183,9 @@ export namespace Command {
     }),
   )
 
-  export const defaultLayer = Layer.suspend(() =>
-    layer.pipe(Layer.provide(Config.defaultLayer), Layer.provide(MCP.defaultLayer), Layer.provide(Skill.defaultLayer)),
+  export const defaultLayer = layer.pipe(
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(MCP.defaultLayer),
+    Layer.provide(Skill.defaultLayer),
   )
 }

packages/opencode/src/effect/bootstrap-runtime.ts

@@ -1,10 +1,9 @@
 import { Layer, ManagedRuntime } from "effect"
 import { memoMap } from "./run-service"
 
-import { FileWatcher } from "@/file/watcher"
 import { Format } from "@/format"
 import { ShareNext } from "@/share/share-next"
 
-export const BootstrapLayer = Layer.mergeAll(Format.defaultLayer, ShareNext.defaultLayer, FileWatcher.defaultLayer)
+export const BootstrapLayer = Layer.mergeAll(Format.defaultLayer, ShareNext.defaultLayer)
 
 export const BootstrapRuntime = ManagedRuntime.make(BootstrapLayer, { memoMap })

packages/opencode/src/file/time.ts

@@ -1,5 +1,6 @@
 import { DateTime, Effect, Layer, Option, Semaphore, Context } from "effect"
 import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
 import { AppFileSystem } from "@/filesystem"
 import { Flag } from "@/flag/flag"
 import type { SessionID } from "@/session/schema"
@@ -111,4 +112,22 @@ export namespace FileTime {
   ).pipe(Layer.orDie)
 
   export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export function read(sessionID: SessionID, file: string) {
+    return runPromise((s) => s.read(sessionID, file))
+  }
+
+  export function get(sessionID: SessionID, file: string) {
+    return runPromise((s) => s.get(sessionID, file))
+  }
+
+  export async function assert(sessionID: SessionID, filepath: string) {
+    return runPromise((s) => s.assert(sessionID, filepath))
+  }
+
+  export async function withLock<T>(filepath: string, fn: () => Promise<T>): Promise<T> {
+    return runPromise((s) => s.withLock(filepath, () => Effect.promise(fn)))
+  }
 }

packages/opencode/src/file/watcher.ts

@@ -8,6 +8,7 @@ import z from "zod"
 import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
 import { Flag } from "@/flag/flag"
 import { Git } from "@/git"
 import { Instance } from "@/project/instance"
@@ -160,4 +161,10 @@ export namespace FileWatcher {
   )
 
   export const defaultLayer = layer.pipe(Layer.provide(Config.defaultLayer), Layer.provide(Git.defaultLayer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export function init() {
+    return runPromise((svc) => svc.init())
+  }
 }

packages/opencode/src/plugin/github-copilot/copilot.ts

@@ -27,12 +27,11 @@ function base(enterpriseUrl?: string) {
   return enterpriseUrl ? `https://copilot-api.${normalizeDomain(enterpriseUrl)}` : "https://api.githubcopilot.com"
 }
 
-function fix(model: Model, url: string): Model {
+function fix(model: Model): Model {
   return {
     ...model,
     api: {
       ...model.api,
-      url,
       npm: "@ai-sdk/github-copilot",
     },
   }
@@ -45,23 +44,19 @@ export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
       id: "github-copilot",
       async models(provider, ctx) {
         if (ctx.auth?.type !== "oauth") {
-          return Object.fromEntries(Object.entries(provider.models).map(([id, model]) => [id, fix(model, base())]))
+          return Object.fromEntries(Object.entries(provider.models).map(([id, model]) => [id, fix(model)]))
         }
 
-        const auth = ctx.auth
-
         return CopilotModels.get(
-          base(auth.enterpriseUrl),
+          base(ctx.auth.enterpriseUrl),
           {
-            Authorization: `Bearer ${auth.refresh}`,
+            Authorization: `Bearer ${ctx.auth.refresh}`,
             "User-Agent": `opencode/${Installation.VERSION}`,
           },
           provider.models,
         ).catch((error) => {
           log.error("failed to fetch copilot models", { error })
-          return Object.fromEntries(
-            Object.entries(provider.models).map(([id, model]) => [id, fix(model, base(auth.enterpriseUrl))]),
-          )
+          return Object.fromEntries(Object.entries(provider.models).map(([id, model]) => [id, fix(model)]))
         })
       },
     },
@@ -71,7 +66,10 @@ export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
         const info = await getAuth()
         if (!info || info.type !== "oauth") return {}
 
+        const baseURL = base(info.enterpriseUrl)
+
         return {
+          baseURL,
           apiKey: "",
           async fetch(request: RequestInfo | URL, init?: RequestInit) {
             const info = await getAuth()

packages/opencode/src/plugin/github-copilot/models.ts

@@ -52,15 +52,13 @@ export namespace CopilotModels {
       (remote.capabilities.supports.vision ?? false) ||
       (remote.capabilities.limits.vision?.supported_media_types ?? []).some((item) => item.startsWith("image/"))
 
-    const isMsgApi = remote.supported_endpoints?.includes("/v1/messages")
-
     return {
       id: key,
       providerID: "github-copilot",
       api: {
         id: remote.id,
-        url: isMsgApi ? `${url}/v1` : url,
-        npm: isMsgApi ? "@ai-sdk/anthropic" : "@ai-sdk/github-copilot",
+        url,
+        npm: "@ai-sdk/github-copilot",
       },
       // API response wins
       status: "active",

packages/opencode/src/project/bootstrap.ts

@@ -2,6 +2,7 @@ import { Plugin } from "../plugin"
 import { Format } from "../format"
 import { LSP } from "../lsp"
 import { File } from "../file"
+import { FileWatcher } from "../file/watcher"
 import { Snapshot } from "../snapshot"
 import { Project } from "./project"
 import { Vcs } from "./vcs"
@@ -10,7 +11,6 @@ import { Command } from "../command"
 import { Instance } from "./instance"
 import { Log } from "@/util/log"
 import { BootstrapRuntime } from "@/effect/bootstrap-runtime"
-import { FileWatcher } from "@/file/watcher"
 import { ShareNext } from "@/share/share-next"
 
 export async function InstanceBootstrap() {
@@ -20,7 +20,7 @@ export async function InstanceBootstrap() {
   void BootstrapRuntime.runPromise(Format.Service.use((svc) => svc.init()))
   await LSP.init()
   File.init()
-  void BootstrapRuntime.runPromise(FileWatcher.Service.use((svc) => svc.init()))
+  FileWatcher.init()
   Vcs.init()
   Snapshot.init()
 

packages/opencode/src/question/index.ts

@@ -2,6 +2,7 @@ import { Deferred, Effect, Layer, Schema, Context } from "effect"
 import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
 import { SessionID, MessageID } from "@/session/schema"
 import { Log } from "@/util/log"
 import z from "zod"
@@ -198,4 +199,26 @@ export namespace Question {
   )
 
   export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function ask(input: {
+    sessionID: SessionID
+    questions: Info[]
+    tool?: { messageID: MessageID; callID: string }
+  }): Promise<Answer[]> {
+    return runPromise((s) => s.ask(input))
+  }
+
+  export async function reply(input: { requestID: QuestionID; answers: Answer[] }) {
+    return runPromise((s) => s.reply(input))
+  }
+
+  export async function reject(requestID: QuestionID) {
+    return runPromise((s) => s.reject(requestID))
+  }
+
+  export async function list() {
+    return runPromise((s) => s.list())
+  }
 }

packages/opencode/src/server/instance/question.ts

@@ -3,7 +3,6 @@ import { describeRoute, validator } from "hono-openapi"
 import { resolver } from "hono-openapi"
 import { QuestionID } from "@/question/schema"
 import { Question } from "../../question"
-import { AppRuntime } from "@/effect/app-runtime"
 import z from "zod"
 import { errors } from "../error"
 import { lazy } from "../../util/lazy"
@@ -28,7 +27,7 @@ export const QuestionRoutes = lazy(() =>
         },
       }),
       async (c) => {
-        const questions = await AppRuntime.runPromise(Question.Service.use((svc) => svc.list()))
+        const questions = await Question.list()
         return c.json(questions)
       },
     )
@@ -60,14 +59,10 @@ export const QuestionRoutes = lazy(() =>
       async (c) => {
         const params = c.req.valid("param")
         const json = c.req.valid("json")
-        await AppRuntime.runPromise(
-          Question.Service.use((svc) =>
-            svc.reply({
-              requestID: params.requestID,
-              answers: json.answers,
-            }),
-          ),
-        )
+        await Question.reply({
+          requestID: params.requestID,
+          answers: json.answers,
+        })
         return c.json(true)
       },
     )
@@ -97,7 +92,7 @@ export const QuestionRoutes = lazy(() =>
       ),
       async (c) => {
         const params = c.req.valid("param")
-        await AppRuntime.runPromise(Question.Service.use((svc) => svc.reject(params.requestID)))
+        await Question.reject(params.requestID)
         return c.json(true)
       },
     ),

packages/opencode/src/server/instance/session.ts

@@ -13,7 +13,6 @@ import { SessionShare } from "@/share/session"
 import { SessionStatus } from "@/session/status"
 import { SessionSummary } from "@/session/summary"
 import { Todo } from "../../session/todo"
-import { Effect } from "effect"
 import { AppRuntime } from "../../effect/app-runtime"
 import { Agent } from "../../agent/agent"
 import { Snapshot } from "@/snapshot"
@@ -725,17 +724,11 @@ export const SessionRoutes = lazy(() =>
       ),
       async (c) => {
         const params = c.req.valid("param")
-        await AppRuntime.runPromise(
-          Effect.gen(function* () {
-            const state = yield* SessionRunState.Service
-            const session = yield* Session.Service
-            yield* state.assertNotBusy(params.sessionID)
-            yield* session.removeMessage({
-              sessionID: params.sessionID,
-              messageID: params.messageID,
-            })
-          }),
-        )
+        await SessionRunState.assertNotBusy(params.sessionID)
+        await Session.removeMessage({
+          sessionID: params.sessionID,
+          messageID: params.messageID,
+        })
         return c.json(true)
       },
     )

packages/opencode/src/session/index.ts

@@ -678,9 +678,7 @@ export namespace Session {
     }),
   )
 
-  export const defaultLayer = Layer.suspend(() =>
-    layer.pipe(Layer.provide(Bus.layer), Layer.provide(Storage.defaultLayer)),
-  )
+  export const defaultLayer = layer.pipe(Layer.provide(Bus.layer), Layer.provide(Storage.defaultLayer))
 
   const { runPromise } = makeRuntime(Service, defaultLayer)
 

packages/opencode/src/session/instruction.ts

@@ -4,6 +4,7 @@ import { Effect, Layer, Context } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
 import { Config } from "@/config/config"
 import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
 import { Flag } from "@/flag/flag"
 import { AppFileSystem } from "@/filesystem"
 import { withTransientReadRetry } from "@/util/effect-http-client"
@@ -237,7 +238,21 @@ export namespace Instruction {
     Layer.provide(FetchHttpClient.layer),
   )
 
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export function clear(messageID: MessageID) {
+    return runPromise((svc) => svc.clear(messageID))
+  }
+
+  export async function systemPaths() {
+    return runPromise((svc) => svc.systemPaths())
+  }
+
   export function loaded(messages: MessageV2.WithParts[]) {
     return extract(messages)
   }
+
+  export async function resolve(messages: MessageV2.WithParts[], filepath: string, messageID: MessageID) {
+    return runPromise((svc) => svc.resolve(messages, filepath, messageID))
+  }
 }

packages/opencode/src/session/run-state.ts

@@ -1,5 +1,6 @@
 import { InstanceState } from "@/effect/instance-state"
 import { Runner } from "@/effect/runner"
+import { makeRuntime } from "@/effect/run-service"
 import { Effect, Layer, Scope, Context } from "effect"
 import { Session } from "."
 import { MessageV2 } from "./message-v2"
@@ -105,4 +106,9 @@ export namespace SessionRunState {
   )
 
   export const defaultLayer = layer.pipe(Layer.provide(SessionStatus.defaultLayer))
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function assertNotBusy(sessionID: SessionID) {
+    return runPromise((svc) => svc.assertNotBusy(sessionID))
+  }
 }

packages/opencode/src/share/share-next.ts

@@ -339,14 +339,12 @@ export namespace ShareNext {
     }),
   )
 
-  export const defaultLayer = Layer.suspend(() =>
-    layer.pipe(
-      Layer.provide(Bus.layer),
-      Layer.provide(Account.defaultLayer),
-      Layer.provide(Config.defaultLayer),
-      Layer.provide(FetchHttpClient.layer),
-      Layer.provide(Provider.defaultLayer),
-      Layer.provide(Session.defaultLayer),
-    ),
+  export const defaultLayer = layer.pipe(
+    Layer.provide(Bus.layer),
+    Layer.provide(Account.defaultLayer),
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(FetchHttpClient.layer),
+    Layer.provide(Provider.defaultLayer),
+    Layer.provide(Session.defaultLayer),
   )
 }

packages/opencode/src/skill/index.ts

@@ -230,13 +230,11 @@ export namespace Skill {
     }),
   )
 
-  export const defaultLayer = Layer.suspend(() =>
-    layer.pipe(
-      Layer.provide(Discovery.defaultLayer),
-      Layer.provide(Config.defaultLayer),
-      Layer.provide(Bus.layer),
-      Layer.provide(AppFileSystem.defaultLayer),
-    ),
+  export const defaultLayer = layer.pipe(
+    Layer.provide(Discovery.defaultLayer),
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(Bus.layer),
+    Layer.provide(AppFileSystem.defaultLayer),
   )
 
   export function fmt(list: Info[], opts: { verbose: boolean }) {

packages/opencode/src/tool/tool.ts

@@ -70,12 +70,7 @@ export namespace Tool {
         ? Def<P, M>
         : never
 
-  function wrap<Parameters extends z.ZodType, Result extends Metadata>(
-    id: string,
-    init: Init<Parameters, Result>,
-    truncate: Truncate.Interface,
-    agents: Agent.Interface,
-  ) {
+  function wrap<Parameters extends z.ZodType, Result extends Metadata>(id: string, init: Init<Parameters, Result>) {
     return () =>
       Effect.gen(function* () {
         const toolInfo = init instanceof Function ? { ...(yield* init()) } : { ...init }
@@ -98,8 +93,8 @@ export namespace Tool {
             if (result.metadata.truncated !== undefined) {
               return result
             }
-            const agent = yield* agents.get(ctx.agent)
-            const truncated = yield* truncate.output(result.output, {}, agent)
+            const agent = yield* Effect.promise(() => Agent.get(ctx.agent))
+            const truncated = yield* Effect.promise(() => Truncate.output(result.output, {}, agent))
             return {
               ...result,
               output: truncated.content,
@@ -117,14 +112,9 @@ export namespace Tool {
   export function define<Parameters extends z.ZodType, Result extends Metadata, R, ID extends string = string>(
     id: ID,
     init: Effect.Effect<Init<Parameters, Result>, never, R>,
-  ): Effect.Effect<Info<Parameters, Result>, never, R | Truncate.Service | Agent.Service> & { id: ID } {
+  ): Effect.Effect<Info<Parameters, Result>, never, R> & { id: ID } {
     return Object.assign(
-      Effect.gen(function* () {
-        const resolved = yield* init
-        const truncate = yield* Truncate.Service
-        const agents = yield* Agent.Service
-        return { id, init: wrap(id, resolved, truncate, agents) }
-      }),
+      Effect.map(init, (init) => ({ id, init: wrap(id, init) })),
       { id },
     )
   }

packages/opencode/src/tool/truncate.ts

@@ -2,6 +2,7 @@ import { NodePath } from "@effect/platform-node"
 import { Cause, Duration, Effect, Layer, Schedule, Context } from "effect"
 import path from "path"
 import type { Agent } from "../agent/agent"
+import { makeRuntime } from "@/effect/run-service"
 import { AppFileSystem } from "@/filesystem"
 import { evaluate } from "@/permission/evaluate"
 import { Identifier } from "../id/id"
@@ -134,4 +135,10 @@ export namespace Truncate {
   )
 
   export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(NodePath.layer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function output(text: string, options: Options = {}, agent?: Agent.Info): Promise<Result> {
+    return runPromise((s) => s.output(text, options, agent))
+  }
 }

packages/opencode/src/util/log.ts

@@ -15,7 +15,6 @@ export namespace Log {
     WARN: 2,
     ERROR: 3,
   }
-  const keep = 10
 
   let level: Level = "INFO"
 
@@ -79,19 +78,15 @@ export namespace Log {
   }
 
   async function cleanup(dir: string) {
-    const files = (
-      await Glob.scan("????-??-??T??????.log", {
-        cwd: dir,
-        absolute: false,
-        include: "file",
-      }).catch(() => [])
-    )
-      .filter((file) => path.basename(file) === file)
-      .sort()
-    if (files.length <= keep) return
+    const files = await Glob.scan("????-??-??T??????.log", {
+      cwd: dir,
+      absolute: true,
+      include: "file",
+    })
+    if (files.length <= 5) return
 
-    const doomed = files.slice(0, -keep)
-    await Promise.all(doomed.map((file) => fs.unlink(path.join(dir, file)).catch(() => {})))
+    const filesToDelete = files.slice(0, -10)
+    await Promise.all(filesToDelete.map((file) => fs.unlink(file).catch(() => {})))
   }
 
   function formatError(error: Error, depth = 0): string {

packages/opencode/test/AGENTS.md

@@ -79,55 +79,3 @@ await using tmp = await tmpdir({
 - Directories are created in the system temp folder with prefix `opencode-test-`
 - Use `await using` for automatic cleanup when the variable goes out of scope
 - Paths are sanitized to strip null bytes (defensive fix for CI environments)
-
-## Testing With Effects
-
-Use `testEffect(...)` from `test/lib/effect.ts` for tests that exercise Effect services or Effect-based workflows.
-
-### Core Pattern
-
-```typescript
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(Layer.mergeAll(MyService.defaultLayer))
-
-describe("my service", () => {
-  it.live("does the thing", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const svc = yield* MyService.Service
-        const out = yield* svc.run()
-        expect(out).toEqual("ok")
-      }),
-    ),
-  )
-})
-```
-
-### `it.effect` vs `it.live`
-
-- Use `it.effect(...)` when the test should run with `TestClock` and `TestConsole`.
-- Use `it.live(...)` when the test depends on real time, filesystem mtimes, child processes, git, locks, or other live OS behavior.
-- Most integration-style tests in this package use `it.live(...)`.
-
-### Effect Fixtures
-
-Prefer the Effect-aware helpers from `fixture/fixture.ts` instead of building a manual runtime in each test.
-
-- `tmpdirScoped(options?)` creates a scoped temp directory and cleans it up when the Effect scope closes.
-- `provideInstance(dir)(effect)` is the low-level helper. It does not create a directory; it just runs an Effect with `Instance.current` bound to `dir`.
-- `provideTmpdirInstance((dir) => effect, options?)` is the convenience helper. It creates a temp directory, binds it as the active instance, and disposes the instance on cleanup.
-- `provideTmpdirServer((input) => effect, options?)` does the same, but also provides the test LLM server.
-
-Use `provideTmpdirInstance(...)` by default when a test only needs one temp instance. Use `tmpdirScoped()` plus `provideInstance(...)` when a test needs multiple directories, custom setup before binding, or needs to switch instance context within one test.
-
-### Style
-
-- Define `const it = testEffect(...)` near the top of the file.
-- Keep the test body inside `Effect.gen(function* () { ... })`.
-- Yield services directly with `yield* MyService.Service` or `yield* MyTool`.
-- Avoid custom `ManagedRuntime`, `attach(...)`, or ad hoc `run(...)` wrappers when `testEffect(...)` already provides the runtime.
-- When a test needs instance-local state, prefer `provideTmpdirInstance(...)` or `provideInstance(...)` over manual `Instance.provide(...)` inside Promise-style tests.

packages/opencode/test/file/time.test.ts

@@ -1,422 +1,445 @@
-import { afterEach, describe, expect } from "bun:test"
-import fs from "fs/promises"
+import { describe, test, expect, afterEach } from "bun:test"
 import path from "path"
-import { Cause, Deferred, Effect, Exit, Fiber, Layer } from "effect"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
+import fs from "fs/promises"
 import { FileTime } from "../../src/file/time"
 import { Instance } from "../../src/project/instance"
 import { SessionID } from "../../src/session/schema"
 import { Filesystem } from "../../src/util/filesystem"
-import { provideInstance, provideTmpdirInstance, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
+import { tmpdir } from "../fixture/fixture"
 
 afterEach(async () => {
   await Instance.disposeAll()
 })
 
-const it = testEffect(Layer.mergeAll(FileTime.defaultLayer, CrossSpawnSpawner.defaultLayer))
+async function touch(file: string, time: number) {
+  const date = new Date(time)
+  await fs.utimes(file, date, date)
+}
 
-const id = SessionID.make("ses_00000000000000000000000001")
-
-const put = (file: string, text: string) => Effect.promise(() => fs.writeFile(file, text, "utf-8"))
-
-const touch = (file: string, time: number) =>
-  Effect.promise(() => {
-    const date = new Date(time)
-    return fs.utimes(file, date, date)
+function gate() {
+  let open!: () => void
+  const wait = new Promise<void>((resolve) => {
+    open = resolve
   })
-
-const read = (id: SessionID, file: string) => FileTime.Service.use((svc) => svc.read(id, file))
-
-const get = (id: SessionID, file: string) => FileTime.Service.use((svc) => svc.get(id, file))
-
-const check = (id: SessionID, file: string) => FileTime.Service.use((svc) => svc.assert(id, file))
-
-const lock = <A>(file: string, fn: () => Effect.Effect<A>) => FileTime.Service.use((svc) => svc.withLock(file, fn))
-
-const fail = Effect.fn("FileTimeTest.fail")(function* <A, E, R>(self: Effect.Effect<A, E, R>) {
-  const exit = yield* self.pipe(Effect.exit)
-  if (Exit.isFailure(exit)) {
-    const err = Cause.squash(exit.cause)
-    return err instanceof Error ? err : new Error(String(err))
-  }
-  throw new Error("expected file time effect to fail")
-})
+  return { open, wait }
+}
 
 describe("file/time", () => {
-  describe("read() and get()", () => {
-    it.live("stores read timestamp", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
+  const sessionID = SessionID.make("ses_00000000000000000000000001")
 
-          const before = yield* get(id, file)
+  describe("read() and get()", () => {
+    test("stores read timestamp", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          const before = await FileTime.get(sessionID, filepath)
           expect(before).toBeUndefined()
 
-          yield* read(id, file)
+          await FileTime.read(sessionID, filepath)
 
-          const after = yield* get(id, file)
+          const after = await FileTime.get(sessionID, filepath)
           expect(after).toBeInstanceOf(Date)
           expect(after!.getTime()).toBeGreaterThan(0)
-        }),
-      ),
-    )
+        },
+      })
+    })
 
-    it.live("tracks separate timestamps per session", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
+    test("tracks separate timestamps per session", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
 
-          const one = SessionID.make("ses_00000000000000000000000002")
-          const two = SessionID.make("ses_00000000000000000000000003")
-          yield* read(one, file)
-          yield* read(two, file)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(SessionID.make("ses_00000000000000000000000002"), filepath)
+          await FileTime.read(SessionID.make("ses_00000000000000000000000003"), filepath)
 
-          const first = yield* get(one, file)
-          const second = yield* get(two, file)
+          const time1 = await FileTime.get(SessionID.make("ses_00000000000000000000000002"), filepath)
+          const time2 = await FileTime.get(SessionID.make("ses_00000000000000000000000003"), filepath)
 
-          expect(first).toBeDefined()
-          expect(second).toBeDefined()
-        }),
-      ),
-    )
+          expect(time1).toBeDefined()
+          expect(time2).toBeDefined()
+        },
+      })
+    })
 
-    it.live("updates timestamp on subsequent reads", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
+    test("updates timestamp on subsequent reads", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
 
-          yield* read(id, file)
-          const first = yield* get(id, file)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+          const first = await FileTime.get(sessionID, filepath)
 
-          yield* read(id, file)
-          const second = yield* get(id, file)
+          await FileTime.read(sessionID, filepath)
+          const second = await FileTime.get(sessionID, filepath)
 
           expect(second!.getTime()).toBeGreaterThanOrEqual(first!.getTime())
-        }),
-      ),
-    )
+        },
+      })
+    })
 
-    it.live("isolates reads by directory", () =>
-      Effect.gen(function* () {
-        const one = yield* tmpdirScoped()
-        const two = yield* tmpdirScoped()
-        const shared = yield* tmpdirScoped()
-        const file = path.join(shared, "file.txt")
-        yield* put(file, "content")
+    test("isolates reads by directory", async () => {
+      await using one = await tmpdir()
+      await using two = await tmpdir()
+      await using shared = await tmpdir()
+      const filepath = path.join(shared.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
 
-        yield* provideInstance(one)(read(id, file))
-        const result = yield* provideInstance(two)(get(id, file))
-        expect(result).toBeUndefined()
-      }),
-    )
+      await Instance.provide({
+        directory: one.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+        },
+      })
+
+      await Instance.provide({
+        directory: two.path,
+        fn: async () => {
+          expect(await FileTime.get(sessionID, filepath)).toBeUndefined()
+        },
+      })
+    })
   })
 
   describe("assert()", () => {
-    it.live("passes when file has not been modified", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+    test("passes when file has not been modified", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)
 
-          yield* read(id, file)
-          yield* check(id, file)
-        }),
-      ),
-    )
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+          await FileTime.assert(sessionID, filepath)
+        },
+      })
+    })
 
-    it.live("throws when file was not read first", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
+    test("throws when file was not read first", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
 
-          const err = yield* fail(check(id, file))
-          expect(err.message).toContain("You must read file")
-        }),
-      ),
-    )
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await expect(FileTime.assert(sessionID, filepath)).rejects.toThrow("You must read file")
+        },
+      })
+    })
 
-    it.live("throws when file was modified after read", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+    test("throws when file was modified after read", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)
 
-          yield* read(id, file)
-          yield* put(file, "modified content")
-          yield* touch(file, 2_000)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+          await fs.writeFile(filepath, "modified content", "utf-8")
+          await touch(filepath, 2_000)
+          await expect(FileTime.assert(sessionID, filepath)).rejects.toThrow("modified since it was last read")
+        },
+      })
+    })
 
-          const err = yield* fail(check(id, file))
-          expect(err.message).toContain("modified since it was last read")
-        }),
-      ),
-    )
+    test("includes timestamps in error message", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)
 
-    it.live("includes timestamps in error message", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+          await fs.writeFile(filepath, "modified", "utf-8")
+          await touch(filepath, 2_000)
 
-          yield* read(id, file)
-          yield* put(file, "modified")
-          yield* touch(file, 2_000)
-
-          const err = yield* fail(check(id, file))
-          expect(err.message).toContain("Last modification:")
-          expect(err.message).toContain("Last read:")
-        }),
-      ),
-    )
+          let error: Error | undefined
+          try {
+            await FileTime.assert(sessionID, filepath)
+          } catch (e) {
+            error = e as Error
+          }
+          expect(error).toBeDefined()
+          expect(error!.message).toContain("Last modification:")
+          expect(error!.message).toContain("Last read:")
+        },
+      })
+    })
   })
 
   describe("withLock()", () => {
-    it.live("executes function within lock", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          let hit = false
+    test("executes function within lock", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
 
-          yield* lock(file, () =>
-            Effect.sync(() => {
-              hit = true
-              return "result"
-            }),
-          )
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          let executed = false
+          await FileTime.withLock(filepath, async () => {
+            executed = true
+            return "result"
+          })
+          expect(executed).toBe(true)
+        },
+      })
+    })
 
-          expect(hit).toBe(true)
-        }),
-      ),
-    )
+    test("returns function result", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
 
-    it.live("returns function result", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          const result = yield* lock(file, () => Effect.succeed("success"))
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          const result = await FileTime.withLock(filepath, async () => {
+            return "success"
+          })
           expect(result).toBe("success")
-        }),
-      ),
-    )
+        },
+      })
+    })
 
-    it.live("serializes concurrent operations on same file", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
+    test("serializes concurrent operations on same file", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
           const order: number[] = []
-          const hold = yield* Deferred.make<void>()
-          const ready = yield* Deferred.make<void>()
+          const hold = gate()
+          const ready = gate()
 
-          const one = yield* lock(file, () =>
-            Effect.gen(function* () {
-              order.push(1)
-              yield* Deferred.succeed(ready, void 0)
-              yield* Deferred.await(hold)
-              order.push(2)
-            }),
-          ).pipe(Effect.forkScoped)
+          const op1 = FileTime.withLock(filepath, async () => {
+            order.push(1)
+            ready.open()
+            await hold.wait
+            order.push(2)
+          })
 
-          yield* Deferred.await(ready)
+          await ready.wait
 
-          const two = yield* lock(file, () =>
-            Effect.sync(() => {
-              order.push(3)
-              order.push(4)
-            }),
-          ).pipe(Effect.forkScoped)
+          const op2 = FileTime.withLock(filepath, async () => {
+            order.push(3)
+            order.push(4)
+          })
 
-          yield* Deferred.succeed(hold, void 0)
-          yield* Fiber.join(one)
-          yield* Fiber.join(two)
+          hold.open()
 
+          await Promise.all([op1, op2])
           expect(order).toEqual([1, 2, 3, 4])
-        }),
-      ),
-    )
+        },
+      })
+    })
 
-    it.live("allows concurrent operations on different files", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const onefile = path.join(dir, "file1.txt")
-          const twofile = path.join(dir, "file2.txt")
-          let one = false
-          let two = false
-          const hold = yield* Deferred.make<void>()
-          const ready = yield* Deferred.make<void>()
+    test("allows concurrent operations on different files", async () => {
+      await using tmp = await tmpdir()
+      const filepath1 = path.join(tmp.path, "file1.txt")
+      const filepath2 = path.join(tmp.path, "file2.txt")
 
-          const a = yield* lock(onefile, () =>
-            Effect.gen(function* () {
-              one = true
-              yield* Deferred.succeed(ready, void 0)
-              yield* Deferred.await(hold)
-              expect(two).toBe(true)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          let started1 = false
+          let started2 = false
+          const hold = gate()
+          const ready = gate()
+
+          const op1 = FileTime.withLock(filepath1, async () => {
+            started1 = true
+            ready.open()
+            await hold.wait
+            expect(started2).toBe(true)
+          })
+
+          await ready.wait
+
+          const op2 = FileTime.withLock(filepath2, async () => {
+            started2 = true
+            hold.open()
+          })
+
+          await Promise.all([op1, op2])
+          expect(started1).toBe(true)
+          expect(started2).toBe(true)
+        },
+      })
+    })
+
+    test("releases lock even if function throws", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await expect(
+            FileTime.withLock(filepath, async () => {
+              throw new Error("Test error")
             }),
-          ).pipe(Effect.forkScoped)
+          ).rejects.toThrow("Test error")
 
-          yield* Deferred.await(ready)
-
-          const b = yield* lock(twofile, () =>
-            Effect.sync(() => {
-              two = true
-            }),
-          ).pipe(Effect.forkScoped)
-
-          yield* Fiber.join(b)
-          yield* Deferred.succeed(hold, void 0)
-          yield* Fiber.join(a)
-
-          expect(one).toBe(true)
-          expect(two).toBe(true)
-        }),
-      ),
-    )
-
-    it.live("releases lock even if function throws", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          const err = yield* fail(lock(file, () => Effect.die(new Error("Test error"))))
-          expect(err.message).toContain("Test error")
-
-          let hit = false
-          yield* lock(file, () =>
-            Effect.sync(() => {
-              hit = true
-            }),
-          )
-          expect(hit).toBe(true)
-        }),
-      ),
-    )
+          let executed = false
+          await FileTime.withLock(filepath, async () => {
+            executed = true
+          })
+          expect(executed).toBe(true)
+        },
+      })
+    })
   })
 
   describe("path normalization", () => {
-    it.live("read with forward slashes, assert with backslashes", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+    test("read with forward slashes, assert with backslashes", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)
 
-          const forward = file.replaceAll("\\", "/")
-          yield* read(id, forward)
-          yield* check(id, file)
-        }),
-      ),
-    )
+      const forwardSlash = filepath.replaceAll("\\", "/")
 
-    it.live("read with backslashes, assert with forward slashes", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, forwardSlash)
+          // assert with the native backslash path should still work
+          await FileTime.assert(sessionID, filepath)
+        },
+      })
+    })
 
-          const forward = file.replaceAll("\\", "/")
-          yield* read(id, file)
-          yield* check(id, forward)
-        }),
-      ),
-    )
+    test("read with backslashes, assert with forward slashes", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)
 
-    it.live("get returns timestamp regardless of slash direction", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
+      const forwardSlash = filepath.replaceAll("\\", "/")
 
-          const forward = file.replaceAll("\\", "/")
-          yield* read(id, forward)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+          // assert with forward slashes should still work
+          await FileTime.assert(sessionID, forwardSlash)
+        },
+      })
+    })
 
-          const result = yield* get(id, file)
+    test("get returns timestamp regardless of slash direction", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+
+      const forwardSlash = filepath.replaceAll("\\", "/")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, forwardSlash)
+          const result = await FileTime.get(sessionID, filepath)
           expect(result).toBeInstanceOf(Date)
-        }),
-      ),
-    )
+        },
+      })
+    })
 
-    it.live("withLock serializes regardless of slash direction", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          const forward = file.replaceAll("\\", "/")
+    test("withLock serializes regardless of slash direction", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+
+      const forwardSlash = filepath.replaceAll("\\", "/")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
           const order: number[] = []
-          const hold = yield* Deferred.make<void>()
-          const ready = yield* Deferred.make<void>()
+          const hold = gate()
+          const ready = gate()
 
-          const one = yield* lock(file, () =>
-            Effect.gen(function* () {
-              order.push(1)
-              yield* Deferred.succeed(ready, void 0)
-              yield* Deferred.await(hold)
-              order.push(2)
-            }),
-          ).pipe(Effect.forkScoped)
+          const op1 = FileTime.withLock(filepath, async () => {
+            order.push(1)
+            ready.open()
+            await hold.wait
+            order.push(2)
+          })
 
-          yield* Deferred.await(ready)
+          await ready.wait
 
-          const two = yield* lock(forward, () =>
-            Effect.sync(() => {
-              order.push(3)
-              order.push(4)
-            }),
-          ).pipe(Effect.forkScoped)
+          // Use forward-slash variant -- should still serialize against op1
+          const op2 = FileTime.withLock(forwardSlash, async () => {
+            order.push(3)
+            order.push(4)
+          })
 
-          yield* Deferred.succeed(hold, void 0)
-          yield* Fiber.join(one)
-          yield* Fiber.join(two)
+          hold.open()
 
+          await Promise.all([op1, op2])
           expect(order).toEqual([1, 2, 3, 4])
-        }),
-      ),
-    )
+        },
+      })
+    })
   })
 
   describe("stat() Filesystem.stat pattern", () => {
-    it.live("reads file modification time via Filesystem.stat()", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+    test("reads file modification time via Filesystem.stat()", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)
 
-          yield* read(id, file)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
 
-          const stat = Filesystem.stat(file)
-          expect(stat?.mtime).toBeInstanceOf(Date)
-          expect(stat!.mtime.getTime()).toBeGreaterThan(0)
+          const stats = Filesystem.stat(filepath)
+          expect(stats?.mtime).toBeInstanceOf(Date)
+          expect(stats!.mtime.getTime()).toBeGreaterThan(0)
 
-          yield* check(id, file)
-        }),
-      ),
-    )
+          await FileTime.assert(sessionID, filepath)
+        },
+      })
+    })
 
-    it.live("detects modification via stat mtime", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "original")
-          yield* touch(file, 1_000)
+    test("detects modification via stat mtime", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "original", "utf-8")
+      await touch(filepath, 1_000)
 
-          yield* read(id, file)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
 
-          const first = Filesystem.stat(file)
+          const originalStat = Filesystem.stat(filepath)
 
-          yield* put(file, "modified")
-          yield* touch(file, 2_000)
+          await fs.writeFile(filepath, "modified", "utf-8")
+          await touch(filepath, 2_000)
 
-          const second = Filesystem.stat(file)
-          expect(second!.mtime.getTime()).toBeGreaterThan(first!.mtime.getTime())
+          const newStat = Filesystem.stat(filepath)
+          expect(newStat!.mtime.getTime()).toBeGreaterThan(originalStat!.mtime.getTime())
 
-          yield* fail(check(id, file))
-        }),
-      ),
-    )
+          await expect(FileTime.assert(sessionID, filepath)).rejects.toThrow()
+        },
+      })
+    })
   })
 })

packages/opencode/test/plugin/github-copilot-models.test.ts

@@ -1,6 +1,5 @@
 import { afterEach, expect, mock, test } from "bun:test"
 import { CopilotModels } from "@/plugin/github-copilot/models"
-import { CopilotAuthPlugin } from "@/plugin/github-copilot/copilot"
 
 const originalFetch = globalThis.fetch
 
@@ -116,45 +115,3 @@ test("preserves temperature support from existing provider models", async () =>
   expect(models["gpt-4o"].capabilities.temperature).toBe(true)
   expect(models["brand-new"].capabilities.temperature).toBe(true)
 })
-
-test("remaps fallback oauth model urls to the enterprise host", async () => {
-  globalThis.fetch = mock(() => Promise.reject(new Error("timeout"))) as unknown as typeof fetch
-
-  const hooks = await CopilotAuthPlugin({
-    client: {} as never,
-    project: {} as never,
-    directory: "",
-    worktree: "",
-    serverUrl: new URL("https://example.com"),
-    $: {} as never,
-  })
-
-  const models = await hooks.provider!.models!(
-    {
-      id: "github-copilot",
-      models: {
-        claude: {
-          id: "claude",
-          providerID: "github-copilot",
-          api: {
-            id: "claude-sonnet-4.5",
-            url: "https://api.githubcopilot.com/v1",
-            npm: "@ai-sdk/anthropic",
-          },
-        },
-      },
-    } as never,
-    {
-      auth: {
-        type: "oauth",
-        refresh: "token",
-        access: "token",
-        expires: Date.now() + 60_000,
-        enterpriseUrl: "ghe.example.com",
-      } as never,
-    },
-  )
-
-  expect(models.claude.api.url).toBe("https://copilot-api.ghe.example.com")
-  expect(models.claude.api.npm).toBe("@ai-sdk/github-copilot")
-})

packages/opencode/test/project/vcs.test.ts

@@ -3,7 +3,6 @@ import { afterEach, describe, expect, test } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
 import { tmpdir } from "../fixture/fixture"
-import { AppRuntime } from "../../src/effect/app-runtime"
 import { FileWatcher } from "../../src/file/watcher"
 import { Instance } from "../../src/project/instance"
 import { GlobalBus } from "../../src/bus/global"
@@ -20,7 +19,7 @@ async function withVcs(directory: string, body: () => Promise<void>) {
   return Instance.provide({
     directory,
     fn: async () => {
-      void AppRuntime.runPromise(FileWatcher.Service.use((svc) => svc.init()))
+      FileWatcher.init()
       Vcs.init()
       await Bun.sleep(500)
       await body()

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

@@ -4,17 +4,6 @@ import { Instance } from "../../src/project/instance"
 import { QuestionID } from "../../src/question/schema"
 import { tmpdir } from "../fixture/fixture"
 import { SessionID } from "../../src/session/schema"
-import { AppRuntime } from "../../src/effect/app-runtime"
-
-const ask = (input: { sessionID: SessionID; questions: Question.Info[]; tool?: { messageID: any; callID: string } }) =>
-  AppRuntime.runPromise(Question.Service.use((svc) => svc.ask(input)))
-
-const list = () => AppRuntime.runPromise(Question.Service.use((svc) => svc.list()))
-
-const reply = (input: { requestID: QuestionID; answers: Question.Answer[] }) =>
-  AppRuntime.runPromise(Question.Service.use((svc) => svc.reply(input)))
-
-const reject = (id: QuestionID) => AppRuntime.runPromise(Question.Service.use((svc) => svc.reject(id)))
 
 afterEach(async () => {
   await Instance.disposeAll()
@@ -22,9 +11,9 @@ afterEach(async () => {
 
 /** Reject all pending questions so dangling Deferred fibers don't hang the test. */
 async function rejectAll() {
-  const pending = await list()
+  const pending = await Question.list()
   for (const req of pending) {
-    await reject(req.id)
+    await Question.reject(req.id)
   }
 }
 
@@ -33,7 +22,7 @@ test("ask - returns pending promise", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const promise = ask({
+      const promise = Question.ask({
         sessionID: SessionID.make("ses_test"),
         questions: [
           {
@@ -69,16 +58,16 @@ test("ask - adds to pending list", async () => {
         },
       ]
 
-      const promise = ask({
+      const askPromise = Question.ask({
         sessionID: SessionID.make("ses_test"),
         questions,
       })
 
-      const pending = await list()
+      const pending = await Question.list()
       expect(pending.length).toBe(1)
       expect(pending[0].questions).toEqual(questions)
       await rejectAll()
-      await promise.catch(() => {})
+      await askPromise.catch(() => {})
     },
   })
 })
@@ -101,20 +90,20 @@ test("reply - resolves the pending ask with answers", async () => {
         },
       ]
 
-      const promise = ask({
+      const askPromise = Question.ask({
         sessionID: SessionID.make("ses_test"),
         questions,
       })
 
-      const pending = await list()
+      const pending = await Question.list()
       const requestID = pending[0].id
 
-      await reply({
+      await Question.reply({
         requestID,
         answers: [["Option 1"]],
       })
 
-      const answers = await promise
+      const answers = await askPromise
       expect(answers).toEqual([["Option 1"]])
     },
   })
@@ -125,7 +114,7 @@ test("reply - removes from pending list", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const promise = ask({
+      const askPromise = Question.ask({
         sessionID: SessionID.make("ses_test"),
         questions: [
           {
@@ -139,17 +128,17 @@ test("reply - removes from pending list", async () => {
         ],
       })
 
-      const pending = await list()
+      const pending = await Question.list()
       expect(pending.length).toBe(1)
 
-      await reply({
+      await Question.reply({
         requestID: pending[0].id,
         answers: [["Option 1"]],
       })
-      await promise
+      await askPromise
 
-      const after = await list()
-      expect(after.length).toBe(0)
+      const pendingAfter = await Question.list()
+      expect(pendingAfter.length).toBe(0)
     },
   })
 })
@@ -159,7 +148,7 @@ test("reply - does nothing for unknown requestID", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      await reply({
+      await Question.reply({
         requestID: QuestionID.make("que_unknown"),
         answers: [["Option 1"]],
       })
@@ -175,7 +164,7 @@ test("reject - throws RejectedError", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const promise = ask({
+      const askPromise = Question.ask({
         sessionID: SessionID.make("ses_test"),
         questions: [
           {
@@ -189,10 +178,10 @@ test("reject - throws RejectedError", async () => {
         ],
       })
 
-      const pending = await list()
-      await reject(pending[0].id)
+      const pending = await Question.list()
+      await Question.reject(pending[0].id)
 
-      await expect(promise).rejects.toBeInstanceOf(Question.RejectedError)
+      await expect(askPromise).rejects.toBeInstanceOf(Question.RejectedError)
     },
   })
 })
@@ -202,7 +191,7 @@ test("reject - removes from pending list", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const promise = ask({
+      const askPromise = Question.ask({
         sessionID: SessionID.make("ses_test"),
         questions: [
           {
@@ -216,14 +205,14 @@ test("reject - removes from pending list", async () => {
         ],
       })
 
-      const pending = await list()
+      const pending = await Question.list()
       expect(pending.length).toBe(1)
 
-      await reject(pending[0].id)
-      promise.catch(() => {}) // Ignore rejection
+      await Question.reject(pending[0].id)
+      askPromise.catch(() => {}) // Ignore rejection
 
-      const after = await list()
-      expect(after.length).toBe(0)
+      const pendingAfter = await Question.list()
+      expect(pendingAfter.length).toBe(0)
     },
   })
 })
@@ -233,7 +222,7 @@ test("reject - does nothing for unknown requestID", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      await reject(QuestionID.make("que_unknown"))
+      await Question.reject(QuestionID.make("que_unknown"))
       // Should not throw
     },
   })
@@ -265,19 +254,19 @@ test("ask - handles multiple questions", async () => {
         },
       ]
 
-      const promise = ask({
+      const askPromise = Question.ask({
         sessionID: SessionID.make("ses_test"),
         questions,
       })
 
-      const pending = await list()
+      const pending = await Question.list()
 
-      await reply({
+      await Question.reply({
         requestID: pending[0].id,
         answers: [["Build"], ["Dev"]],
       })
 
-      const answers = await promise
+      const answers = await askPromise
       expect(answers).toEqual([["Build"], ["Dev"]])
     },
   })
@@ -290,7 +279,7 @@ test("list - returns all pending requests", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const p1 = ask({
+      const p1 = Question.ask({
         sessionID: SessionID.make("ses_test1"),
         questions: [
           {
@@ -301,7 +290,7 @@ test("list - returns all pending requests", async () => {
         ],
       })
 
-      const p2 = ask({
+      const p2 = Question.ask({
         sessionID: SessionID.make("ses_test2"),
         questions: [
           {
@@ -312,7 +301,7 @@ test("list - returns all pending requests", async () => {
         ],
       })
 
-      const pending = await list()
+      const pending = await Question.list()
       expect(pending.length).toBe(2)
       await rejectAll()
       p1.catch(() => {})
@@ -326,7 +315,7 @@ test("list - returns empty when no pending", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const pending = await list()
+      const pending = await Question.list()
       expect(pending.length).toBe(0)
     },
   })
@@ -339,7 +328,7 @@ test("questions stay isolated by directory", async () => {
   const p1 = Instance.provide({
     directory: one.path,
     fn: () =>
-      ask({
+      Question.ask({
         sessionID: SessionID.make("ses_one"),
         questions: [
           {
@@ -354,7 +343,7 @@ test("questions stay isolated by directory", async () => {
   const p2 = Instance.provide({
     directory: two.path,
     fn: () =>
-      ask({
+      Question.ask({
         sessionID: SessionID.make("ses_two"),
         questions: [
           {
@@ -368,11 +357,11 @@ test("questions stay isolated by directory", async () => {
 
   const onePending = await Instance.provide({
     directory: one.path,
-    fn: () => list(),
+    fn: () => Question.list(),
   })
   const twoPending = await Instance.provide({
     directory: two.path,
-    fn: () => list(),
+    fn: () => Question.list(),
   })
 
   expect(onePending.length).toBe(1)
@@ -382,11 +371,11 @@ test("questions stay isolated by directory", async () => {
 
   await Instance.provide({
     directory: one.path,
-    fn: () => reject(onePending[0].id),
+    fn: () => Question.reject(onePending[0].id),
   })
   await Instance.provide({
     directory: two.path,
-    fn: () => reject(twoPending[0].id),
+    fn: () => Question.reject(twoPending[0].id),
   })
 
   await p1.catch(() => {})
@@ -396,10 +385,10 @@ test("questions stay isolated by directory", async () => {
 test("pending question rejects on instance dispose", async () => {
   await using tmp = await tmpdir({ git: true })
 
-  const pending = Instance.provide({
+  const ask = Instance.provide({
     directory: tmp.path,
     fn: () => {
-      return ask({
+      return Question.ask({
         sessionID: SessionID.make("ses_dispose"),
         questions: [
           {
@@ -411,7 +400,7 @@ test("pending question rejects on instance dispose", async () => {
       })
     },
   })
-  const result = pending.then(
+  const result = ask.then(
     () => "resolved" as const,
     (err) => err,
   )
@@ -419,8 +408,8 @@ test("pending question rejects on instance dispose", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const items = await list()
-      expect(items).toHaveLength(1)
+      const pending = await Question.list()
+      expect(pending).toHaveLength(1)
       await Instance.dispose()
     },
   })
@@ -431,10 +420,10 @@ test("pending question rejects on instance dispose", async () => {
 test("pending question rejects on instance reload", async () => {
   await using tmp = await tmpdir({ git: true })
 
-  const pending = Instance.provide({
+  const ask = Instance.provide({
     directory: tmp.path,
     fn: () => {
-      return ask({
+      return Question.ask({
         sessionID: SessionID.make("ses_reload"),
         questions: [
           {
@@ -446,7 +435,7 @@ test("pending question rejects on instance reload", async () => {
       })
     },
   })
-  const result = pending.then(
+  const result = ask.then(
     () => "resolved" as const,
     (err) => err,
   )
@@ -454,8 +443,8 @@ test("pending question rejects on instance reload", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const items = await list()
-      expect(items).toHaveLength(1)
+      const pending = await Question.list()
+      expect(pending).toHaveLength(1)
       await Instance.reload({ directory: tmp.path })
     },
   })

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

@@ -1,9 +1,11 @@
 import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
-import { Effect } from "effect"
 import { Instance } from "../../src/project/instance"
 import { Server } from "../../src/server/server"
 import { Session } from "../../src/session"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { MessageID, PartID, type SessionID } from "../../src/session/schema"
 import { SessionPrompt } from "../../src/session/prompt"
+import { SessionRunState } from "../../src/session/run-state"
 import { Log } from "../../src/util/log"
 import { tmpdir } from "../fixture/fixture"
 
@@ -14,6 +16,25 @@ afterEach(async () => {
   await Instance.disposeAll()
 })
 
+async function user(sessionID: SessionID, text: string) {
+  const msg = await Session.updateMessage({
+    id: MessageID.ascending(),
+    role: "user",
+    sessionID,
+    agent: "build",
+    model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
+    time: { created: Date.now() },
+  })
+  await Session.updatePart({
+    id: PartID.ascending(),
+    sessionID,
+    messageID: msg.id,
+    type: "text",
+    text,
+  })
+  return msg
+}
+
 describe("session action routes", () => {
   test("abort route calls SessionPrompt.cancel", async () => {
     await using tmp = await tmpdir({ git: true })
@@ -24,7 +45,9 @@ describe("session action routes", () => {
         const cancel = spyOn(SessionPrompt, "cancel").mockResolvedValue()
         const app = Server.Default().app
 
-        const res = await app.request(`/session/${session.id}/abort`, { method: "POST" })
+        const res = await app.request(`/session/${session.id}/abort`, {
+          method: "POST",
+        })
 
         expect(res.status).toBe(200)
         expect(await res.json()).toBe(true)
@@ -34,4 +57,28 @@ describe("session action routes", () => {
       },
     })
   })
+
+  test("delete message route returns 400 when session is busy", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const session = await Session.create({})
+        const msg = await user(session.id, "hello")
+        const busy = spyOn(SessionRunState, "assertNotBusy").mockRejectedValue(new Session.BusyError(session.id))
+        const remove = spyOn(Session, "removeMessage").mockResolvedValue(msg.id)
+        const app = Server.Default().app
+
+        const res = await app.request(`/session/${session.id}/message/${msg.id}`, {
+          method: "DELETE",
+        })
+
+        expect(res.status).toBe(400)
+        expect(busy).toHaveBeenCalledWith(session.id)
+        expect(remove).not.toHaveBeenCalled()
+
+        await Session.remove(session.id)
+      },
+    })
+  })
 })

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

@@ -1,6 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import path from "path"
-import { Effect } from "effect"
 import { ModelID, ProviderID } from "../../src/provider/schema"
 import { Instruction } from "../../src/session/instruction"
 import type { MessageV2 } from "../../src/session/message-v2"
@@ -9,9 +8,6 @@ import { MessageID, PartID, SessionID } from "../../src/session/schema"
 import { Global } from "../../src/global"
 import { tmpdir } from "../fixture/fixture"
 
-const run = <A>(effect: Effect.Effect<A, any, Instruction.Service>) =>
-  Effect.runPromise(effect.pipe(Effect.provide(Instruction.defaultLayer)))
-
 function loaded(filepath: string): MessageV2.WithParts[] {
   const sessionID = SessionID.make("session-loaded-1")
   const messageID = MessageID.make("message-loaded-1")
@@ -61,22 +57,17 @@ describe("Instruction.resolve", () => {
     })
     await Instance.provide({
       directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const system = yield* svc.systemPaths()
-              expect(system.has(path.join(tmp.path, "AGENTS.md"))).toBe(true)
+      fn: async () => {
+        const system = await Instruction.systemPaths()
+        expect(system.has(path.join(tmp.path, "AGENTS.md"))).toBe(true)
 
-              const results = yield* svc.resolve(
-                [],
-                path.join(tmp.path, "src", "file.ts"),
-                MessageID.make("message-test-1"),
-              )
-              expect(results).toEqual([])
-            }),
-          ),
-        ),
+        const results = await Instruction.resolve(
+          [],
+          path.join(tmp.path, "src", "file.ts"),
+          MessageID.make("message-test-1"),
+        )
+        expect(results).toEqual([])
+      },
     })
   })
 
@@ -89,23 +80,18 @@ describe("Instruction.resolve", () => {
     })
     await Instance.provide({
       directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const system = yield* svc.systemPaths()
-              expect(system.has(path.join(tmp.path, "subdir", "AGENTS.md"))).toBe(false)
+      fn: async () => {
+        const system = await Instruction.systemPaths()
+        expect(system.has(path.join(tmp.path, "subdir", "AGENTS.md"))).toBe(false)
 
-              const results = yield* svc.resolve(
-                [],
-                path.join(tmp.path, "subdir", "nested", "file.ts"),
-                MessageID.make("message-test-2"),
-              )
-              expect(results.length).toBe(1)
-              expect(results[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
-            }),
-          ),
-        ),
+        const results = await Instruction.resolve(
+          [],
+          path.join(tmp.path, "subdir", "nested", "file.ts"),
+          MessageID.make("message-test-2"),
+        )
+        expect(results.length).toBe(1)
+        expect(results[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
+      },
     })
   })
 
@@ -118,19 +104,14 @@ describe("Instruction.resolve", () => {
     })
     await Instance.provide({
       directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const filepath = path.join(tmp.path, "subdir", "AGENTS.md")
-              const system = yield* svc.systemPaths()
-              expect(system.has(filepath)).toBe(false)
+      fn: async () => {
+        const filepath = path.join(tmp.path, "subdir", "AGENTS.md")
+        const system = await Instruction.systemPaths()
+        expect(system.has(filepath)).toBe(false)
 
-              const results = yield* svc.resolve([], filepath, MessageID.make("message-test-3"))
-              expect(results).toEqual([])
-            }),
-          ),
-        ),
+        const results = await Instruction.resolve([], filepath, MessageID.make("message-test-3"))
+        expect(results).toEqual([])
+      },
     })
   })
 
@@ -143,22 +124,17 @@ describe("Instruction.resolve", () => {
     })
     await Instance.provide({
       directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
-              const id = MessageID.make("message-claim-1")
+      fn: async () => {
+        const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
+        const id = MessageID.make("message-claim-1")
 
-              const first = yield* svc.resolve([], filepath, id)
-              const second = yield* svc.resolve([], filepath, id)
+        const first = await Instruction.resolve([], filepath, id)
+        const second = await Instruction.resolve([], filepath, id)
 
-              expect(first).toHaveLength(1)
-              expect(first[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
-              expect(second).toEqual([])
-            }),
-          ),
-        ),
+        expect(first).toHaveLength(1)
+        expect(first[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
+        expect(second).toEqual([])
+      },
     })
   })
 
@@ -171,23 +147,18 @@ describe("Instruction.resolve", () => {
     })
     await Instance.provide({
       directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
-              const id = MessageID.make("message-claim-2")
+      fn: async () => {
+        const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
+        const id = MessageID.make("message-claim-2")
 
-              const first = yield* svc.resolve([], filepath, id)
-              yield* svc.clear(id)
-              const second = yield* svc.resolve([], filepath, id)
+        const first = await Instruction.resolve([], filepath, id)
+        await Instruction.clear(id)
+        const second = await Instruction.resolve([], filepath, id)
 
-              expect(first).toHaveLength(1)
-              expect(second).toHaveLength(1)
-              expect(second[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
-            }),
-          ),
-        ),
+        expect(first).toHaveLength(1)
+        expect(second).toHaveLength(1)
+        expect(second[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
+      },
     })
   })
 
@@ -200,19 +171,15 @@ describe("Instruction.resolve", () => {
     })
     await Instance.provide({
       directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const agents = path.join(tmp.path, "subdir", "AGENTS.md")
-              const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
-              const id = MessageID.make("message-claim-3")
+      fn: async () => {
+        const agents = path.join(tmp.path, "subdir", "AGENTS.md")
+        const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
+        const id = MessageID.make("message-claim-3")
 
-              const results = yield* svc.resolve(loaded(agents), filepath, id)
-              expect(results).toEqual([])
-            }),
-          ),
-        ),
+        const results = await Instruction.resolve(loaded(agents), filepath, id)
+
+        expect(results).toEqual([])
+      },
     })
   })
 
@@ -254,16 +221,11 @@ describe("Instruction.systemPaths OPENCODE_CONFIG_DIR", () => {
     try {
       await Instance.provide({
         directory: projectTmp.path,
-        fn: () =>
-          run(
-            Instruction.Service.use((svc) =>
-              Effect.gen(function* () {
-                const paths = yield* svc.systemPaths()
-                expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(true)
-                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(false)
-              }),
-            ),
-          ),
+        fn: async () => {
+          const paths = await Instruction.systemPaths()
+          expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(true)
+          expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(false)
+        },
       })
     } finally {
       ;(Global.Path as { config: string }).config = originalGlobalConfig
@@ -286,16 +248,11 @@ describe("Instruction.systemPaths OPENCODE_CONFIG_DIR", () => {
     try {
       await Instance.provide({
         directory: projectTmp.path,
-        fn: () =>
-          run(
-            Instruction.Service.use((svc) =>
-              Effect.gen(function* () {
-                const paths = yield* svc.systemPaths()
-                expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(false)
-                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
-              }),
-            ),
-          ),
+        fn: async () => {
+          const paths = await Instruction.systemPaths()
+          expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(false)
+          expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
+        },
       })
     } finally {
       ;(Global.Path as { config: string }).config = originalGlobalConfig
@@ -317,15 +274,10 @@ describe("Instruction.systemPaths OPENCODE_CONFIG_DIR", () => {
     try {
       await Instance.provide({
         directory: projectTmp.path,
-        fn: () =>
-          run(
-            Instruction.Service.use((svc) =>
-              Effect.gen(function* () {
-                const paths = yield* svc.systemPaths()
-                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
-              }),
-            ),
-          ),
+        fn: async () => {
+          const paths = await Instruction.systemPaths()
+          expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
+        },
       })
     } finally {
       ;(Global.Path as { config: string }).config = originalGlobalConfig

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

@@ -7,21 +7,12 @@ import { Instance } from "../../src/project/instance"
 import { LSP } from "../../src/lsp"
 import { AppFileSystem } from "../../src/filesystem"
 import { Format } from "../../src/format"
-import { Agent } from "../../src/agent/agent"
 import { Bus } from "../../src/bus"
-import { Truncate } from "../../src/tool/truncate"
 import { tmpdir } from "../fixture/fixture"
 import { SessionID, MessageID } from "../../src/session/schema"
 
 const runtime = ManagedRuntime.make(
-  Layer.mergeAll(
-    LSP.defaultLayer,
-    AppFileSystem.defaultLayer,
-    Format.defaultLayer,
-    Bus.layer,
-    Truncate.defaultLayer,
-    Agent.defaultLayer,
-  ),
+  Layer.mergeAll(LSP.defaultLayer, AppFileSystem.defaultLayer, Format.defaultLayer, Bus.layer),
 )
 
 const baseCtx = {

packages/opencode/test/tool/bash.test.ts

@@ -8,7 +8,6 @@ import { Instance } from "../../src/project/instance"
 import { Filesystem } from "../../src/util/filesystem"
 import { tmpdir } from "../fixture/fixture"
 import type { Permission } from "../../src/permission"
-import { Agent } from "../../src/agent/agent"
 import { Truncate } from "../../src/tool/truncate"
 import { SessionID, MessageID } from "../../src/session/schema"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
@@ -16,13 +15,7 @@ import { AppFileSystem } from "../../src/filesystem"
 import { Plugin } from "../../src/plugin"
 
 const runtime = ManagedRuntime.make(
-  Layer.mergeAll(
-    CrossSpawnSpawner.defaultLayer,
-    AppFileSystem.defaultLayer,
-    Plugin.defaultLayer,
-    Truncate.defaultLayer,
-    Agent.defaultLayer,
-  ),
+  Layer.mergeAll(CrossSpawnSpawner.defaultLayer, AppFileSystem.defaultLayer, Plugin.defaultLayer),
 )
 
 function initBash() {

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

@@ -9,10 +9,8 @@ import { FileTime } from "../../src/file/time"
 import { LSP } from "../../src/lsp"
 import { AppFileSystem } from "../../src/filesystem"
 import { Format } from "../../src/format"
-import { Agent } from "../../src/agent/agent"
 import { Bus } from "../../src/bus"
 import { BusEvent } from "../../src/bus/bus-event"
-import { Truncate } from "../../src/tool/truncate"
 import { SessionID, MessageID } from "../../src/session/schema"
 
 const ctx = {
@@ -35,16 +33,23 @@ async function touch(file: string, time: number) {
   await fs.utimes(file, date, date)
 }
 
+async function wait(check: () => void, timeout = 1_000) {
+  const end = Date.now() + timeout
+  let err: unknown
+  while (Date.now() < end) {
+    try {
+      check()
+      return
+    } catch (cause) {
+      err = cause
+      await Bun.sleep(10)
+    }
+  }
+  throw err
+}
+
 const runtime = ManagedRuntime.make(
-  Layer.mergeAll(
-    LSP.defaultLayer,
-    FileTime.defaultLayer,
-    AppFileSystem.defaultLayer,
-    Format.defaultLayer,
-    Bus.layer,
-    Truncate.defaultLayer,
-    Agent.defaultLayer,
-  ),
+  Layer.mergeAll(LSP.defaultLayer, FileTime.defaultLayer, AppFileSystem.defaultLayer, Format.defaultLayer, Bus.layer),
 )
 
 afterAll(async () => {
@@ -143,7 +148,7 @@ describe("tool.edit", () => {
             ),
           )
 
-          expect(events).toContain("updated")
+          await wait(() => expect(events).toContain("updated"))
           unsubUpdated()
         },
       })
@@ -374,7 +379,7 @@ describe("tool.edit", () => {
             ),
           )
 
-          expect(events).toContain("updated")
+          await wait(() => expect(events).toContain("updated"))
           unsubUpdated()
         },
       })

packages/opencode/test/tool/grep.test.ts

@@ -6,12 +6,8 @@ import { Instance } from "../../src/project/instance"
 import { tmpdir } from "../fixture/fixture"
 import { SessionID, MessageID } from "../../src/session/schema"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { Truncate } from "../../src/tool/truncate"
-import { Agent } from "../../src/agent/agent"
 
-const runtime = ManagedRuntime.make(
-  Layer.mergeAll(CrossSpawnSpawner.defaultLayer, Truncate.defaultLayer, Agent.defaultLayer),
-)
+const runtime = ManagedRuntime.make(Layer.mergeAll(CrossSpawnSpawner.defaultLayer))
 
 function initGrep() {
   return runtime.runPromise(GrepTool.pipe(Effect.flatMap((info) => info.init())))

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

@@ -4,9 +4,7 @@ import { Tool } from "../../src/tool/tool"
 import { QuestionTool } from "../../src/tool/question"
 import { Question } from "../../src/question"
 import { SessionID, MessageID } from "../../src/session/schema"
-import { Agent } from "../../src/agent/agent"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { Truncate } from "../../src/tool/truncate"
 import { provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
 
@@ -21,9 +19,7 @@ const ctx = {
   ask: () => Effect.void,
 }
 
-const it = testEffect(
-  Layer.mergeAll(Question.defaultLayer, CrossSpawnSpawner.defaultLayer, Truncate.defaultLayer, Agent.defaultLayer),
-)
+const it = testEffect(Layer.mergeAll(Question.defaultLayer, CrossSpawnSpawner.defaultLayer))
 
 const pending = Effect.fn("QuestionToolTest.pending")(function* (question: Question.Interface) {
   for (;;) {

packages/opencode/test/tool/read.test.ts

@@ -11,7 +11,6 @@ import { Instance } from "../../src/project/instance"
 import { SessionID, MessageID } from "../../src/session/schema"
 import { Instruction } from "../../src/session/instruction"
 import { ReadTool } from "../../src/tool/read"
-import { Truncate } from "../../src/tool/truncate"
 import { Tool } from "../../src/tool/tool"
 import { Filesystem } from "../../src/util/filesystem"
 import { provideInstance, tmpdirScoped } from "../fixture/fixture"
@@ -42,7 +41,6 @@ const it = testEffect(
     FileTime.defaultLayer,
     Instruction.defaultLayer,
     LSP.defaultLayer,
-    Truncate.defaultLayer,
   ),
 )
 

packages/opencode/test/tool/skill.test.ts

@@ -1,8 +1,6 @@
 import { Effect, Layer, ManagedRuntime } from "effect"
-import { Agent } from "../../src/agent/agent"
 import { Skill } from "../../src/skill"
 import { Ripgrep } from "../../src/file/ripgrep"
-import { Truncate } from "../../src/tool/truncate"
 import { afterEach, describe, expect, test } from "bun:test"
 import path from "path"
 import { pathToFileURL } from "url"
@@ -152,9 +150,7 @@ Use this skill.
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const runtime = ManagedRuntime.make(
-            Layer.mergeAll(Skill.defaultLayer, Ripgrep.defaultLayer, Truncate.defaultLayer, Agent.defaultLayer),
-          )
+          const runtime = ManagedRuntime.make(Layer.mergeAll(Skill.defaultLayer, Ripgrep.defaultLayer))
           const info = await runtime.runPromise(SkillTool)
           const tool = await runtime.runPromise(info.init())
           const requests: Array<Omit<Permission.Request, "id" | "sessionID" | "tool">> = []

packages/opencode/test/tool/task.test.ts

@@ -10,7 +10,6 @@ import type { SessionPrompt } from "../../src/session/prompt"
 import { MessageID, PartID } from "../../src/session/schema"
 import { ModelID, ProviderID } from "../../src/provider/schema"
 import { TaskTool, type TaskPromptOps } from "../../src/tool/task"
-import { Truncate } from "../../src/tool/truncate"
 import { ToolRegistry } from "../../src/tool/registry"
 import { provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
@@ -30,7 +29,6 @@ const it = testEffect(
     Config.defaultLayer,
     CrossSpawnSpawner.defaultLayer,
     Session.defaultLayer,
-    Truncate.defaultLayer,
     ToolRegistry.defaultLayer,
   ),
 )

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

@@ -1,11 +1,7 @@
 import { describe, test, expect } from "bun:test"
-import { Effect, Layer, ManagedRuntime } from "effect"
+import { Effect } from "effect"
 import z from "zod"
-import { Agent } from "../../src/agent/agent"
 import { Tool } from "../../src/tool/tool"
-import { Truncate } from "../../src/tool/truncate"
-
-const runtime = ManagedRuntime.make(Layer.mergeAll(Truncate.defaultLayer, Agent.defaultLayer))
 
 const params = z.object({ input: z.string() })
 
@@ -25,7 +21,7 @@ describe("Tool.define", () => {
     const original = makeTool("test")
     const originalExecute = original.execute
 
-    const info = await runtime.runPromise(Tool.define("test-tool", Effect.succeed(original)))
+    const info = await Effect.runPromise(Tool.define("test-tool", Effect.succeed(original)))
 
     await Effect.runPromise(info.init())
     await Effect.runPromise(info.init())
@@ -35,7 +31,7 @@ describe("Tool.define", () => {
   })
 
   test("effect-defined tool returns fresh objects and is unaffected", async () => {
-    const info = await runtime.runPromise(
+    const info = await Effect.runPromise(
       Tool.define(
         "test-fn-tool",
         Effect.succeed(() => Effect.succeed(makeTool("test"))),
@@ -49,7 +45,7 @@ describe("Tool.define", () => {
   })
 
   test("object-defined tool returns distinct objects per init() call", async () => {
-    const info = await runtime.runPromise(Tool.define("test-copy", Effect.succeed(makeTool("test"))))
+    const info = await Effect.runPromise(Tool.define("test-copy", Effect.succeed(makeTool("test"))))
 
     const first = await Effect.runPromise(info.init())
     const second = await Effect.runPromise(info.init())

packages/opencode/test/tool/truncation.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect } from "bun:test"
 import { NodeFileSystem } from "@effect/platform-node"
 import { Effect, FileSystem, Layer } from "effect"
-import { Truncate } from "../../src/tool/truncate"
+import { Truncate, Truncate as TruncateSvc } from "../../src/tool/truncate"
 import { Identifier } from "../../src/id/id"
 import { Process } from "../../src/util/process"
 import { Filesystem } from "../../src/util/filesystem"
@@ -12,155 +12,120 @@ import { writeFileStringScoped } from "../lib/filesystem"
 const FIXTURES_DIR = path.join(import.meta.dir, "fixtures")
 const ROOT = path.resolve(import.meta.dir, "..", "..")
 
-const it = testEffect(Layer.mergeAll(Truncate.defaultLayer, NodeFileSystem.layer))
-
 describe("Truncate", () => {
   describe("output", () => {
-    it.live("truncates large json file by bytes", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = yield* Effect.promise(() => Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json")))
-        const result = yield* svc.output(content)
+    test("truncates large json file by bytes", async () => {
+      const content = await Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json"))
+      const result = await Truncate.output(content)
 
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("truncated...")
-        if (result.truncated) expect(result.outputPath).toBeDefined()
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("truncated...")
+      if (result.truncated) expect(result.outputPath).toBeDefined()
+    })
 
-    it.live("returns content unchanged when under limits", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "line1\nline2\nline3"
-        const result = yield* svc.output(content)
+    test("returns content unchanged when under limits", async () => {
+      const content = "line1\nline2\nline3"
+      const result = await Truncate.output(content)
 
-        expect(result.truncated).toBe(false)
-        expect(result.content).toBe(content)
-      }),
-    )
+      expect(result.truncated).toBe(false)
+      expect(result.content).toBe(content)
+    })
 
-    it.live("truncates by line count", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 10 })
+    test("truncates by line count", async () => {
+      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+      const result = await Truncate.output(lines, { maxLines: 10 })
 
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("...90 lines truncated...")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("...90 lines truncated...")
+    })
 
-    it.live("truncates by byte count", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "a".repeat(1000)
-        const result = yield* svc.output(content, { maxBytes: 100 })
+    test("truncates by byte count", async () => {
+      const content = "a".repeat(1000)
+      const result = await Truncate.output(content, { maxBytes: 100 })
 
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("truncated...")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("truncated...")
+    })
 
-    it.live("truncates from head by default", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 3 })
+    test("truncates from head by default", async () => {
+      const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
+      const result = await Truncate.output(lines, { maxLines: 3 })
 
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("line0")
-        expect(result.content).toContain("line1")
-        expect(result.content).toContain("line2")
-        expect(result.content).not.toContain("line9")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("line0")
+      expect(result.content).toContain("line1")
+      expect(result.content).toContain("line2")
+      expect(result.content).not.toContain("line9")
+    })
 
-    it.live("truncates from tail when direction is tail", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 3, direction: "tail" })
+    test("truncates from tail when direction is tail", async () => {
+      const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
+      const result = await Truncate.output(lines, { maxLines: 3, direction: "tail" })
 
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("line7")
-        expect(result.content).toContain("line8")
-        expect(result.content).toContain("line9")
-        expect(result.content).not.toContain("line0")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("line7")
+      expect(result.content).toContain("line8")
+      expect(result.content).toContain("line9")
+      expect(result.content).not.toContain("line0")
+    })
 
     test("uses default MAX_LINES and MAX_BYTES", () => {
       expect(Truncate.MAX_LINES).toBe(2000)
       expect(Truncate.MAX_BYTES).toBe(50 * 1024)
     })
 
-    it.live("large single-line file truncates with byte message", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = yield* Effect.promise(() => Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json")))
-        const result = yield* svc.output(content)
+    test("large single-line file truncates with byte message", async () => {
+      const content = await Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json"))
+      const result = await Truncate.output(content)
 
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("bytes truncated...")
-        expect(Buffer.byteLength(content, "utf-8")).toBeGreaterThan(Truncate.MAX_BYTES)
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("bytes truncated...")
+      expect(Buffer.byteLength(content, "utf-8")).toBeGreaterThan(Truncate.MAX_BYTES)
+    })
 
-    it.live("writes full output to file when truncated", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 10 })
+    test("writes full output to file when truncated", async () => {
+      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+      const result = await Truncate.output(lines, { maxLines: 10 })
 
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("The tool call succeeded but the output was truncated")
-        expect(result.content).toContain("Grep")
-        if (!result.truncated) throw new Error("expected truncated")
-        expect(result.outputPath).toBeDefined()
-        expect(result.outputPath).toContain("tool_")
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("The tool call succeeded but the output was truncated")
+      expect(result.content).toContain("Grep")
+      if (!result.truncated) throw new Error("expected truncated")
+      expect(result.outputPath).toBeDefined()
+      expect(result.outputPath).toContain("tool_")
 
-        const written = yield* Effect.promise(() => Filesystem.readText(result.outputPath!))
-        expect(written).toBe(lines)
-      }),
-    )
+      const written = await Filesystem.readText(result.outputPath!)
+      expect(written).toBe(lines)
+    })
 
-    it.live("suggests Task tool when agent has task permission", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const agent = { permission: [{ permission: "task", pattern: "*", action: "allow" as const }] }
-        const result = yield* svc.output(lines, { maxLines: 10 }, agent as any)
+    test("suggests Task tool when agent has task permission", async () => {
+      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+      const agent = { permission: [{ permission: "task", pattern: "*", action: "allow" as const }] }
+      const result = await Truncate.output(lines, { maxLines: 10 }, agent as any)
 
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("Grep")
-        expect(result.content).toContain("Task tool")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("Grep")
+      expect(result.content).toContain("Task tool")
+    })
 
-    it.live("omits Task tool hint when agent lacks task permission", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const agent = { permission: [{ permission: "task", pattern: "*", action: "deny" as const }] }
-        const result = yield* svc.output(lines, { maxLines: 10 }, agent as any)
+    test("omits Task tool hint when agent lacks task permission", async () => {
+      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+      const agent = { permission: [{ permission: "task", pattern: "*", action: "deny" as const }] }
+      const result = await Truncate.output(lines, { maxLines: 10 }, agent as any)
 
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("Grep")
-        expect(result.content).not.toContain("Task tool")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("Grep")
+      expect(result.content).not.toContain("Task tool")
+    })
 
-    it.live("does not write file when not truncated", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "short content"
-        const result = yield* svc.output(content)
+    test("does not write file when not truncated", async () => {
+      const content = "short content"
+      const result = await Truncate.output(content)
 
-        expect(result.truncated).toBe(false)
-        if (result.truncated) throw new Error("expected not truncated")
-        expect("outputPath" in result).toBe(false)
-      }),
-    )
+      expect(result.truncated).toBe(false)
+      if (result.truncated) throw new Error("expected not truncated")
+      expect("outputPath" in result).toBe(false)
+    })
 
     test("loads truncate effect in a fresh process", async () => {
       const out = await Process.run([process.execPath, "run", path.join(ROOT, "src", "tool", "truncate.ts")], {
@@ -173,10 +138,10 @@ describe("Truncate", () => {
 
   describe("cleanup", () => {
     const DAY_MS = 24 * 60 * 60 * 1000
+    const it = testEffect(Layer.mergeAll(TruncateSvc.defaultLayer, NodeFileSystem.layer))
 
     it.live("deletes files older than 7 days and preserves recent files", () =>
       Effect.gen(function* () {
-        const svc = yield* Truncate.Service
         const fs = yield* FileSystem.FileSystem
 
         yield* fs.makeDirectory(Truncate.DIR, { recursive: true })
@@ -186,7 +151,7 @@ describe("Truncate", () => {
 
         yield* writeFileStringScoped(old, "old content")
         yield* writeFileStringScoped(recent, "recent content")
-        yield* svc.cleanup()
+        yield* TruncateSvc.Service.use((s) => s.cleanup())
 
         expect(yield* fs.exists(old)).toBe(false)
         expect(yield* fs.exists(recent)).toBe(true)

packages/opencode/test/tool/webfetch.test.ts

@@ -1,9 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import path from "path"
-import { Effect, Layer } from "effect"
+import { Effect } from "effect"
 import { FetchHttpClient } from "effect/unstable/http"
-import { Agent } from "../../src/agent/agent"
-import { Truncate } from "../../src/tool/truncate"
 import { Instance } from "../../src/project/instance"
 import { WebFetchTool } from "../../src/tool/webfetch"
 import { SessionID, MessageID } from "../../src/session/schema"
@@ -26,11 +24,10 @@ async function withFetch(fetch: (req: Request) => Response | Promise<Response>,
   await fn(server.url)
 }
 
-function exec(args: { url: string; format: "text" | "markdown" | "html" }) {
+function initTool() {
   return WebFetchTool.pipe(
     Effect.flatMap((info) => info.init()),
-    Effect.flatMap((tool) => tool.execute(args, ctx)),
-    Effect.provide(Layer.mergeAll(FetchHttpClient.layer, Truncate.defaultLayer, Agent.defaultLayer)),
+    Effect.provide(FetchHttpClient.layer),
     Effect.runPromise,
   )
 }
@@ -44,7 +41,10 @@ describe("tool.webfetch", () => {
         await Instance.provide({
           directory: projectRoot,
           fn: async () => {
-            const result = await exec({ url: new URL("/image.png", url).toString(), format: "markdown" })
+            const webfetch = await initTool()
+            const result = await Effect.runPromise(
+              webfetch.execute({ url: new URL("/image.png", url).toString(), format: "markdown" }, ctx),
+            )
             expect(result.output).toBe("Image fetched successfully")
             expect(result.attachments).toBeDefined()
             expect(result.attachments?.length).toBe(1)
@@ -72,7 +72,10 @@ describe("tool.webfetch", () => {
         await Instance.provide({
           directory: projectRoot,
           fn: async () => {
-            const result = await exec({ url: new URL("/image.svg", url).toString(), format: "html" })
+            const webfetch = await initTool()
+            const result = await Effect.runPromise(
+              webfetch.execute({ url: new URL("/image.svg", url).toString(), format: "html" }, ctx),
+            )
             expect(result.output).toContain("<svg")
             expect(result.attachments).toBeUndefined()
           },
@@ -92,7 +95,10 @@ describe("tool.webfetch", () => {
         await Instance.provide({
           directory: projectRoot,
           fn: async () => {
-            const result = await exec({ url: new URL("/file.txt", url).toString(), format: "text" })
+            const webfetch = await initTool()
+            const result = await Effect.runPromise(
+              webfetch.execute({ url: new URL("/file.txt", url).toString(), format: "text" }, ctx),
+            )
             expect(result.output).toBe("hello from webfetch")
             expect(result.attachments).toBeUndefined()
           },

packages/opencode/test/tool/write.test.ts

@@ -9,9 +9,7 @@ import { AppFileSystem } from "../../src/filesystem"
 import { FileTime } from "../../src/file/time"
 import { Bus } from "../../src/bus"
 import { Format } from "../../src/format"
-import { Truncate } from "../../src/tool/truncate"
 import { Tool } from "../../src/tool/tool"
-import { Agent } from "../../src/agent/agent"
 import { SessionID, MessageID } from "../../src/session/schema"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
 import { provideTmpdirInstance } from "../fixture/fixture"
@@ -40,8 +38,6 @@ const it = testEffect(
     Bus.layer,
     Format.defaultLayer,
     CrossSpawnSpawner.defaultLayer,
-    Truncate.defaultLayer,
-    Agent.defaultLayer,
   ),
 )
 

packages/opencode/test/util/log.test.ts

@@ -1,44 +0,0 @@
-import { afterEach, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { Global } from "../../src/global"
-import { Log } from "../../src/util/log"
-import { tmpdir } from "../fixture/fixture"
-
-const log = Global.Path.log
-
-afterEach(() => {
-  Global.Path.log = log
-})
-
-async function files(dir: string) {
-  let last = ""
-  let same = 0
-
-  for (let i = 0; i < 50; i++) {
-    const list = (await fs.readdir(dir)).sort()
-    const next = JSON.stringify(list)
-    same = next === last ? same + 1 : 0
-    if (same >= 2 && list.length === 11) return list
-    last = next
-    await Bun.sleep(10)
-  }
-
-  return (await fs.readdir(dir)).sort()
-}
-
-test("init cleanup keeps the newest timestamped logs", async () => {
-  await using tmp = await tmpdir()
-  Global.Path.log = tmp.path
-
-  const list = Array.from({ length: 12 }, (_, i) => `2000-01-${String(i + 1).padStart(2, "0")}T000000.log`)
-
-  await Promise.all(list.map((file) => fs.writeFile(path.join(tmp.path, file), file)))
-
-  await Log.init({ print: false, dev: false })
-
-  const next = await files(tmp.path)
-
-  expect(next).not.toContain(list[0]!)
-  expect(next).toContain(list.at(-1)!)
-})

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -387,29 +387,6 @@ export type EventQuestionRejected = {
   }
 }
 
-export type Todo = {
-  /**
-   * Brief description of the task
-   */
-  content: string
-  /**
-   * Current status of the task: pending, in_progress, completed, cancelled
-   */
-  status: string
-  /**
-   * Priority level of the task: high, medium, low
-   */
-  priority: string
-}
-
-export type EventTodoUpdated = {
-  type: "todo.updated"
-  properties: {
-    sessionID: string
-    todos: Array<Todo>
-  }
-}
-
 export type SessionStatus =
   | {
       type: "idle"
@@ -446,6 +423,29 @@ export type EventSessionCompacted = {
   }
 }
 
+export type Todo = {
+  /**
+   * Brief description of the task
+   */
+  content: string
+  /**
+   * Current status of the task: pending, in_progress, completed, cancelled
+   */
+  status: string
+  /**
+   * Priority level of the task: high, medium, low
+   */
+  priority: string
+}
+
+export type EventTodoUpdated = {
+  type: "todo.updated"
+  properties: {
+    sessionID: string
+    todos: Array<Todo>
+  }
+}
+
 export type EventWorktreeReady = {
   type: "worktree.ready"
   properties: {
@@ -998,10 +998,10 @@ export type Event =
   | EventQuestionAsked
   | EventQuestionReplied
   | EventQuestionRejected
-  | EventTodoUpdated
   | EventSessionStatus
   | EventSessionIdle
   | EventSessionCompacted
+  | EventTodoUpdated
   | EventWorktreeReady
   | EventWorktreeFailed
   | EventPtyCreated

packages/sdk/openapi.json

@@ -8139,50 +8139,6 @@
         },
         "required": ["type", "properties"]
       },
-      "Todo": {
-        "type": "object",
-        "properties": {
-          "content": {
-            "description": "Brief description of the task",
-            "type": "string"
-          },
-          "status": {
-            "description": "Current status of the task: pending, in_progress, completed, cancelled",
-            "type": "string"
-          },
-          "priority": {
-            "description": "Priority level of the task: high, medium, low",
-            "type": "string"
-          }
-        },
-        "required": ["content", "status", "priority"]
-      },
-      "Event.todo.updated": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "todo.updated"
-          },
-          "properties": {
-            "type": "object",
-            "properties": {
-              "sessionID": {
-                "type": "string",
-                "pattern": "^ses.*"
-              },
-              "todos": {
-                "type": "array",
-                "items": {
-                  "$ref": "#/components/schemas/Todo"
-                }
-              }
-            },
-            "required": ["sessionID", "todos"]
-          }
-        },
-        "required": ["type", "properties"]
-      },
       "SessionStatus": {
         "anyOf": [
           {
@@ -8289,6 +8245,50 @@
         },
         "required": ["type", "properties"]
       },
+      "Todo": {
+        "type": "object",
+        "properties": {
+          "content": {
+            "description": "Brief description of the task",
+            "type": "string"
+          },
+          "status": {
+            "description": "Current status of the task: pending, in_progress, completed, cancelled",
+            "type": "string"
+          },
+          "priority": {
+            "description": "Priority level of the task: high, medium, low",
+            "type": "string"
+          }
+        },
+        "required": ["content", "status", "priority"]
+      },
+      "Event.todo.updated": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "todo.updated"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "sessionID": {
+                "type": "string",
+                "pattern": "^ses.*"
+              },
+              "todos": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/Todo"
+                }
+              }
+            },
+            "required": ["sessionID", "todos"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
       "Event.worktree.ready": {
         "type": "object",
         "properties": {
@@ -9949,9 +9949,6 @@
           {
             "$ref": "#/components/schemas/Event.question.rejected"
           },
-          {
-            "$ref": "#/components/schemas/Event.todo.updated"
-          },
           {
             "$ref": "#/components/schemas/Event.session.status"
           },
@@ -9961,6 +9958,9 @@
           {
             "$ref": "#/components/schemas/Event.session.compacted"
           },
+          {
+            "$ref": "#/components/schemas/Event.todo.updated"
+          },
           {
             "$ref": "#/components/schemas/Event.worktree.ready"
           },