effectify Worktree service with Effect layer and facades

Migrate Worktree from direct Instance ALS reads to the Effect service
pattern: define Interface, Service, layer (yielding InstanceContext),
and promise facades using runPromiseInstance. Wire into instances.ts.

packages/opencode/specs/effect-migration.md

@@ -126,10 +126,10 @@ Done now:
 
 Still open and likely worth migrating:
 
-- [x] `Plugin`
+- [ ] `Plugin`
 - [ ] `ToolRegistry`
 - [ ] `Pty`
-- [ ] `Worktree`
+- [x] `Worktree`
 - [ ] `Installation`
 - [ ] `Bus`
 - [ ] `Command`

packages/opencode/src/bus/bus-event.ts

@@ -1,5 +1,5 @@
 import z from "zod"
-import type { ZodObject, ZodRawShape } from "zod"
+import type { ZodType } from "zod"
 import { Log } from "../util/log"
 
 export namespace BusEvent {
@@ -9,7 +9,7 @@ export namespace BusEvent {
 
   const registry = new Map<string, Definition>()
 
-  export function define<Type extends string, Properties extends ZodObject<ZodRawShape>>(type: Type, properties: Properties) {
+  export function define<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
     const result = {
       type,
       properties,

packages/opencode/src/bus/global.ts

@@ -4,7 +4,7 @@ export const GlobalBus = new EventEmitter<{
   event: [
     {
       directory?: string
-      payload: { type: string; properties: Record<string, unknown> }
+      payload: any
     },
   ]
 }>()

packages/opencode/src/control-plane/workspace.ts

@@ -124,7 +124,7 @@ export namespace Workspace {
       await parseSSE(res.body, stop, (event) => {
         GlobalBus.emit("event", {
           directory: space.id,
-          payload: event as { type: string; properties: Record<string, unknown> },
+          payload: event,
         })
       })
       // Wait 250ms and retry if SSE connection fails

packages/opencode/src/effect/instances.ts

@@ -10,7 +10,7 @@ import { ProviderAuth } from "@/provider/auth"
 import { Question } from "@/question"
 import { Skill } from "@/skill/skill"
 import { Snapshot } from "@/snapshot"
-import { Plugin } from "@/plugin"
+import { Worktree } from "@/worktree"
 import { InstanceContext } from "./instance-context"
 import { registerDisposer } from "./instance-registry"
 
@@ -27,7 +27,7 @@ export type InstanceServices =
   | File.Service
   | Skill.Service
   | Snapshot.Service
-  | Plugin.Service
+  | Worktree.Service
 
 // NOTE: LayerMap only passes the key (directory string) to lookup, but we need
 // the full instance context (directory, worktree, project). We read from the
@@ -35,7 +35,7 @@ export type InstanceServices =
 // runPromiseInstance -> Instances.get, which always runs inside Instance.provide.
 // This should go away once the old Instance type is removed and lookup can load
 // the full context directly.
-function lookup(_key: string): Layer.Layer<InstanceServices> {
+function lookup(_key: string) {
   const ctx = Layer.sync(InstanceContext, () => InstanceContext.of(Instance.current))
   return Layer.mergeAll(
     Layer.fresh(Question.layer),
@@ -48,7 +48,7 @@ function lookup(_key: string): Layer.Layer<InstanceServices> {
     Layer.fresh(File.layer),
     Layer.fresh(Skill.defaultLayer),
     Layer.fresh(Snapshot.defaultLayer),
-    Layer.fresh(Plugin.layer),
+    Layer.fresh(Worktree.layer),
   ).pipe(Layer.provide(ctx))
 }
 

packages/opencode/src/mcp/index.ts

@@ -11,6 +11,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js"
 import { Config } from "../config/config"
 import { Log } from "../util/log"
+import { Process } from "../util/process"
 import { NamedError } from "@opencode-ai/util/error"
 import z from "zod/v4"
 import { Instance } from "../project/instance"
@@ -166,14 +167,10 @@ export namespace MCP {
     const queue = [pid]
     while (queue.length > 0) {
       const current = queue.shift()!
-      const proc = Bun.spawn(["pgrep", "-P", String(current)], { stdout: "pipe", stderr: "pipe" })
-      const [code, out] = await Promise.all([proc.exited, new Response(proc.stdout).text()]).catch(
-        () => [-1, ""] as const,
-      )
-      if (code !== 0) continue
-      for (const tok of out.trim().split(/\s+/)) {
+      const lines = await Process.lines(["pgrep", "-P", String(current)], { nothrow: true })
+      for (const tok of lines) {
         const cpid = parseInt(tok, 10)
-        if (!isNaN(cpid) && pids.indexOf(cpid) === -1) {
+        if (!isNaN(cpid) && !pids.includes(cpid)) {
           pids.push(cpid)
           queue.push(cpid)
         }

packages/opencode/src/plugin/index.ts

@@ -5,15 +5,13 @@ import { Log } from "../util/log"
 import { createOpencodeClient } from "@opencode-ai/sdk"
 import { Server } from "../server/server"
 import { BunProc } from "../bun"
+import { Instance } from "../project/instance"
 import { Flag } from "../flag/flag"
 import { CodexAuthPlugin } from "./codex"
 import { Session } from "../session"
 import { NamedError } from "@opencode-ai/util/error"
 import { CopilotAuthPlugin } from "./copilot"
 import { gitlabAuthPlugin as GitlabAuthPlugin } from "@gitlab/opencode-gitlab-auth"
-import { Effect, Fiber, Layer, ServiceMap } from "effect"
-import { InstanceContext } from "@/effect/instance-context"
-import { runPromiseInstance } from "@/effect/runtime"
 
 export namespace Plugin {
   const log = Log.create({ service: "plugin" })
@@ -21,173 +19,126 @@ export namespace Plugin {
   // Built-in plugins that are directly imported (not installed from npm)
   const INTERNAL_PLUGINS: PluginInstance[] = [CodexAuthPlugin, CopilotAuthPlugin, GitlabAuthPlugin]
 
-  export interface Interface {
-    readonly trigger: <
-      Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool">,
-      Input = Parameters<Required<Hooks>[Name]>[0],
-      Output = Parameters<Required<Hooks>[Name]>[1],
-    >(
-      name: Name,
-      input: Input,
-      output: Output,
-    ) => Effect.Effect<Output>
-    readonly list: () => Effect.Effect<Hooks[]>
-    readonly init: () => Effect.Effect<void>
-  }
+  const state = Instance.state(async () => {
+    const client = createOpencodeClient({
+      baseUrl: "http://localhost:4096",
+      directory: Instance.directory,
+      headers: Flag.OPENCODE_SERVER_PASSWORD
+        ? {
+            Authorization: `Basic ${Buffer.from(`${Flag.OPENCODE_SERVER_USERNAME ?? "opencode"}:${Flag.OPENCODE_SERVER_PASSWORD}`).toString("base64")}`,
+          }
+        : undefined,
+      fetch: async (...args) => Server.Default().fetch(...args),
+    })
+    const config = await Config.get()
+    const hooks: Hooks[] = []
+    const input: PluginInput = {
+      client,
+      project: Instance.project,
+      worktree: Instance.worktree,
+      directory: Instance.directory,
+      get serverUrl(): URL {
+        return Server.url ?? new URL("http://localhost:4096")
+      },
+      $: Bun.$,
+    }
 
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Plugin") {}
+    for (const plugin of INTERNAL_PLUGINS) {
+      log.info("loading internal plugin", { name: plugin.name })
+      const init = await plugin(input).catch((err) => {
+        log.error("failed to load internal plugin", { name: plugin.name, error: err })
+      })
+      if (init) hooks.push(init)
+    }
 
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const instance = yield* InstanceContext
-      const hooks: Hooks[] = []
+    let plugins = config.plugin ?? []
+    if (plugins.length) await Config.waitForDependencies()
 
-      const load = Effect.fn("Plugin.load")(function* () {
-        yield* Effect.promise(async () => {
-          const client = createOpencodeClient({
-            baseUrl: "http://localhost:4096",
-            directory: instance.directory,
-            headers: Flag.OPENCODE_SERVER_PASSWORD
-              ? {
-                  Authorization: `Basic ${Buffer.from(`${Flag.OPENCODE_SERVER_USERNAME ?? "opencode"}:${Flag.OPENCODE_SERVER_PASSWORD}`).toString("base64")}`,
-                }
-              : undefined,
-            fetch: async (...args) => Server.Default().fetch(...args),
+    for (let plugin of plugins) {
+      // ignore old codex plugin since it is supported first party now
+      if (plugin.includes("opencode-openai-codex-auth") || plugin.includes("opencode-copilot-auth")) continue
+      log.info("loading plugin", { path: plugin })
+      if (!plugin.startsWith("file://")) {
+        const lastAtIndex = plugin.lastIndexOf("@")
+        const pkg = lastAtIndex > 0 ? plugin.substring(0, lastAtIndex) : plugin
+        const version = lastAtIndex > 0 ? plugin.substring(lastAtIndex + 1) : "latest"
+        plugin = await BunProc.install(pkg, version).catch((err) => {
+          const cause = err instanceof Error ? err.cause : err
+          const detail = cause instanceof Error ? cause.message : String(cause ?? err)
+          log.error("failed to install plugin", { pkg, version, error: detail })
+          Bus.publish(Session.Event.Error, {
+            error: new NamedError.Unknown({
+              message: `Failed to install plugin ${pkg}@${version}: ${detail}`,
+            }).toObject(),
           })
-          const config = await Config.get()
-          const input: PluginInput = {
-            client,
-            project: instance.project,
-            worktree: instance.worktree,
-            directory: instance.directory,
-            get serverUrl(): URL {
-              return Server.url ?? new URL("http://localhost:4096")
-            },
-            $: Bun.$,
-          }
-
-          for (const plugin of INTERNAL_PLUGINS) {
-            log.info("loading internal plugin", { name: plugin.name })
-            const init = await plugin(input).catch((err) => {
-              log.error("failed to load internal plugin", { name: plugin.name, error: err })
-            })
-            if (init) hooks.push(init)
-          }
-
-          let plugins = config.plugin ?? []
-          if (plugins.length) await Config.waitForDependencies()
-
-          for (let plugin of plugins) {
-            // ignore old codex plugin since it is supported first party now
-            if (plugin.includes("opencode-openai-codex-auth") || plugin.includes("opencode-copilot-auth")) continue
-            log.info("loading plugin", { path: plugin })
-            if (!plugin.startsWith("file://")) {
-              const lastAtIndex = plugin.lastIndexOf("@")
-              const pkg = lastAtIndex > 0 ? plugin.substring(0, lastAtIndex) : plugin
-              const version = lastAtIndex > 0 ? plugin.substring(lastAtIndex + 1) : "latest"
-              plugin = await BunProc.install(pkg, version).catch((err) => {
-                const cause = err instanceof Error ? err.cause : err
-                const detail = cause instanceof Error ? cause.message : String(cause ?? err)
-                log.error("failed to install plugin", { pkg, version, error: detail })
-                Bus.publish(Session.Event.Error, {
-                  error: new NamedError.Unknown({
-                    message: `Failed to install plugin ${pkg}@${version}: ${detail}`,
-                  }).toObject(),
-                })
-                return ""
-              })
-              if (!plugin) continue
-            }
-            // Prevent duplicate initialization when plugins export the same function
-            // as both a named export and default export (e.g., `export const X` and `export default X`).
-            // Object.entries(mod) would return both entries pointing to the same function reference.
-            await import(plugin)
-              .then(async (mod) => {
-                const seen = new Set<PluginInstance>()
-                for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
-                  if (seen.has(fn)) continue
-                  seen.add(fn)
-                  hooks.push(await fn(input))
-                }
-              })
-              .catch((err) => {
-                const message = err instanceof Error ? err.message : String(err)
-                log.error("failed to load plugin", { path: plugin, error: message })
-                Bus.publish(Session.Event.Error, {
-                  error: new NamedError.Unknown({
-                    message: `Failed to load plugin ${plugin}: ${message}`,
-                  }).toObject(),
-                })
-              })
+          return ""
+        })
+        if (!plugin) continue
+      }
+      // Prevent duplicate initialization when plugins export the same function
+      // as both a named export and default export (e.g., `export const X` and `export default X`).
+      // Object.entries(mod) would return both entries pointing to the same function reference.
+      await import(plugin)
+        .then(async (mod) => {
+          const seen = new Set<PluginInstance>()
+          for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
+            if (seen.has(fn)) continue
+            seen.add(fn)
+            hooks.push(await fn(input))
           }
         })
-      })
-
-      const loadFiber = yield* load().pipe(
-        Effect.catchCause((cause) => Effect.sync(() => log.error("init failed", { cause }))),
-        Effect.forkScoped,
-      )
-
-      const trigger = Effect.fn("Plugin.trigger")(function* <
-        Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool">,
-        Input = Parameters<Required<Hooks>[Name]>[0],
-        Output = Parameters<Required<Hooks>[Name]>[1],
-      >(name: Name, input: Input, output: Output) {
-        if (!name) return output
-        yield* Fiber.join(loadFiber)
-        yield* Effect.promise(async () => {
-          for (const hook of hooks) {
-            const fn = hook[name]
-            if (!fn) continue
-            // @ts-expect-error if you feel adventurous, please fix the typing, make sure to bump the try-counter if you
-            // give up.
-            // try-counter: 2
-            await fn(input, output)
-          }
-        })
-        return output
-      })
-
-      const list = Effect.fn("Plugin.list")(function* () {
-        yield* Fiber.join(loadFiber)
-        return hooks
-      })
-
-      const init = Effect.fn("Plugin.init")(function* () {
-        yield* Fiber.join(loadFiber)
-        yield* Effect.promise(async () => {
-          const config = await Config.get()
-          for (const hook of hooks) {
-            await (hook as any).config?.(config)
-          }
-          Bus.subscribeAll(async (input) => {
-            for (const hook of hooks) {
-              hook["event"]?.({
-                event: input,
-              })
-            }
+        .catch((err) => {
+          const message = err instanceof Error ? err.message : String(err)
+          log.error("failed to load plugin", { path: plugin, error: message })
+          Bus.publish(Session.Event.Error, {
+            error: new NamedError.Unknown({
+              message: `Failed to load plugin ${plugin}: ${message}`,
+            }).toObject(),
           })
         })
-      })
+    }
 
-      return Service.of({ trigger, list, init })
-    }),
-  )
+    return {
+      hooks,
+      input,
+    }
+  })
 
   export async function trigger<
     Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool">,
     Input = Parameters<Required<Hooks>[Name]>[0],
     Output = Parameters<Required<Hooks>[Name]>[1],
   >(name: Name, input: Input, output: Output): Promise<Output> {
-    return runPromiseInstance(Service.use((svc) => svc.trigger(name, input, output)))
+    if (!name) return output
+    for (const hook of await state().then((x) => x.hooks)) {
+      const fn = hook[name]
+      if (!fn) continue
+      // @ts-expect-error if you feel adventurous, please fix the typing, make sure to bump the try-counter if you
+      // give up.
+      // try-counter: 2
+      await fn(input, output)
+    }
+    return output
   }
 
-  export async function list(): Promise<Hooks[]> {
-    return runPromiseInstance(Service.use((svc) => svc.list()))
+  export async function list() {
+    return state().then((x) => x.hooks)
   }
 
   export async function init() {
-    return runPromiseInstance(Service.use((svc) => svc.init()))
+    const hooks = await state().then((x) => x.hooks)
+    const config = await Config.get()
+    for (const hook of hooks) {
+      // @ts-expect-error this is because we haven't moved plugin to sdk v2
+      await hook.config?.(config)
+    }
+    Bus.subscribeAll(async (input) => {
+      const hooks = await state().then((x) => x.hooks)
+      for (const hook of hooks) {
+        hook["event"]?.({
+          event: input,
+        })
+      }
+    })
   }
 }

packages/opencode/src/session/prompt.ts

@@ -32,7 +32,6 @@ import { Flag } from "../flag/flag"
 import { ulid } from "ulid"
 import { spawn } from "child_process"
 import { Command } from "../command"
-import { $ } from "bun"
 import { pathToFileURL, fileURLToPath } from "url"
 import { ConfigMarkdown } from "../config/markdown"
 import { SessionSummary } from "./summary"
@@ -48,6 +47,7 @@ import { iife } from "@/util/iife"
 import { Shell } from "@/shell/shell"
 import { Truncate } from "@/tool/truncate"
 import { decodeDataUrl } from "@/util/data-url"
+import { Process } from "@/util/process"
 
 // @ts-ignore
 globalThis.AI_SDK_LOG_WARNINGS = false
@@ -1812,15 +1812,13 @@ NOTE: At any point in time through this workflow you should feel free to ask the
       template = template + "\n\n" + input.arguments
     }
 
-    const shell = ConfigMarkdown.shell(template)
-    if (shell.length > 0) {
+    const shellMatches = ConfigMarkdown.shell(template)
+    if (shellMatches.length > 0) {
+      const sh = Shell.preferred()
       const results = await Promise.all(
-        shell.map(async ([, cmd]) => {
-          try {
-            return await $`${{ raw: cmd }}`.quiet().nothrow().text()
-          } catch (error) {
-            return `Error executing command: ${error instanceof Error ? error.message : String(error)}`
-          }
+        shellMatches.map(async ([, cmd]) => {
+          const out = await Process.text([cmd], { shell: sh, nothrow: true })
+          return out.text
         }),
       )
       let index = 0

packages/opencode/src/worktree/index.ts

@@ -9,12 +9,14 @@ import { Project } from "../project/project"
 import { Database, eq } from "../storage/db"
 import { ProjectTable } from "../project/project.sql"
 import type { ProjectID } from "../project/schema"
-import { fn } from "../util/fn"
 import { Log } from "../util/log"
 import { Process } from "../util/process"
 import { git } from "../util/git"
 import { BusEvent } from "@/bus/bus-event"
 import { GlobalBus } from "@/bus/global"
+import { InstanceContext } from "@/effect/instance-context"
+import { runPromiseInstance } from "@/effect/runtime"
+import { Effect, Layer, ServiceMap } from "effect"
 
 export namespace Worktree {
   const log = Log.create({ service: "worktree" })
@@ -267,7 +269,7 @@ export namespace Worktree {
     return process.platform === "win32" ? normalized.toLowerCase() : normalized
   }
 
-  async function candidate(root: string, base?: string) {
+  async function candidateName(worktreeDir: string, root: string, base?: string) {
     for (const attempt of Array.from({ length: 26 }, (_, i) => i)) {
       const name = base ? (attempt === 0 ? base : `${base}-${randomName()}`) : randomName()
       const branch = `opencode/${name}`
@@ -277,7 +279,7 @@ export namespace Worktree {
 
       const ref = `refs/heads/${branch}`
       const branchCheck = await git(["show-ref", "--verify", "--quiet", ref], {
-        cwd: Instance.worktree,
+        cwd: worktreeDir,
       })
       if (branchCheck.exitCode === 0) continue
 
@@ -335,338 +337,419 @@ export namespace Worktree {
     }, 0)
   }
 
+  // ---------------------------------------------------------------------------
+  // Effect service
+  // ---------------------------------------------------------------------------
+
+  export interface Interface {
+    readonly makeWorktreeInfo: (name?: string) => Effect.Effect<Info>
+    readonly createFromInfo: (info: Info, startCommand?: string) => Effect.Effect<() => Promise<void>>
+    readonly create: (input?: CreateInput) => Effect.Effect<Info>
+    readonly remove: (input: RemoveInput) => Effect.Effect<boolean>
+    readonly reset: (input: ResetInput) => Effect.Effect<boolean>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Worktree") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const instance = yield* InstanceContext
+
+      const makeWorktreeInfoEffect = Effect.fn("Worktree.makeWorktreeInfo")(function* (name?: string) {
+        return yield* Effect.promise(async () => {
+          if (instance.project.vcs !== "git") {
+            throw new NotGitError({ message: "Worktrees are only supported for git projects" })
+          }
+
+          const root = path.join(Global.Path.data, "worktree", instance.project.id)
+          await fs.mkdir(root, { recursive: true })
+
+          const base = name ? slug(name) : ""
+          return candidateName(instance.worktree, root, base || undefined)
+        })
+      })
+
+      const createFromInfoEffect = Effect.fn("Worktree.createFromInfo")(function* (
+        info: Info,
+        startCommand?: string,
+      ) {
+        return yield* Effect.promise(async (): Promise<() => Promise<void>> => {
+          const created = await git(["worktree", "add", "--no-checkout", "-b", info.branch, info.directory], {
+            cwd: instance.worktree,
+          })
+          if (created.exitCode !== 0) {
+            throw new CreateFailedError({ message: errorText(created) || "Failed to create git worktree" })
+          }
+
+          await Project.addSandbox(instance.project.id, info.directory).catch(() => undefined)
+
+          const projectID = instance.project.id
+          const extra = startCommand?.trim()
+
+          return () => {
+            const start = async () => {
+              const populated = await git(["reset", "--hard"], { cwd: info.directory })
+              if (populated.exitCode !== 0) {
+                const message = errorText(populated) || "Failed to populate worktree"
+                log.error("worktree checkout failed", { directory: info.directory, message })
+                GlobalBus.emit("event", {
+                  directory: info.directory,
+                  payload: {
+                    type: Event.Failed.type,
+                    properties: {
+                      message,
+                    },
+                  },
+                })
+                return
+              }
+
+              const booted = await Instance.provide({
+                directory: info.directory,
+                init: InstanceBootstrap,
+                fn: () => undefined,
+              })
+                .then(() => true)
+                .catch((error) => {
+                  const message = error instanceof Error ? error.message : String(error)
+                  log.error("worktree bootstrap failed", { directory: info.directory, message })
+                  GlobalBus.emit("event", {
+                    directory: info.directory,
+                    payload: {
+                      type: Event.Failed.type,
+                      properties: {
+                        message,
+                      },
+                    },
+                  })
+                  return false
+                })
+              if (!booted) return
+
+              GlobalBus.emit("event", {
+                directory: info.directory,
+                payload: {
+                  type: Event.Ready.type,
+                  properties: {
+                    name: info.name,
+                    branch: info.branch,
+                  },
+                },
+              })
+
+              await runStartScripts(info.directory, { projectID, extra })
+            }
+
+            return start().catch((error) => {
+              log.error("worktree start task failed", { directory: info.directory, error })
+            })
+          }
+        })
+      })
+
+      const createEffect = Effect.fn("Worktree.create")(function* (input?: CreateInput) {
+        const parsed = input ? CreateInput.optional().parse(input) : undefined
+        const info = yield* makeWorktreeInfoEffect(parsed?.name)
+        const bootstrap = yield* createFromInfoEffect(info, parsed?.startCommand)
+        // This is needed due to how worktrees currently work in the
+        // desktop app
+        setTimeout(() => {
+          bootstrap()
+        }, 0)
+        return info
+      })
+
+      const removeEffect = Effect.fn("Worktree.remove")(function* (input: RemoveInput) {
+        return yield* Effect.promise(async () => {
+          const parsed = RemoveInput.parse(input)
+          if (instance.project.vcs !== "git") {
+            throw new NotGitError({ message: "Worktrees are only supported for git projects" })
+          }
+
+          const directory = await canonical(parsed.directory)
+          const locate = async (stdout: Uint8Array | undefined) => {
+            const lines = outputText(stdout)
+              .split("\n")
+              .map((line) => line.trim())
+            const entries = lines.reduce<{ path?: string; branch?: string }[]>((acc, line) => {
+              if (!line) return acc
+              if (line.startsWith("worktree ")) {
+                acc.push({ path: line.slice("worktree ".length).trim() })
+                return acc
+              }
+              const current = acc[acc.length - 1]
+              if (!current) return acc
+              if (line.startsWith("branch ")) {
+                current.branch = line.slice("branch ".length).trim()
+              }
+              return acc
+            }, [])
+
+            return (async () => {
+              for (const item of entries) {
+                if (!item.path) continue
+                const key = await canonical(item.path)
+                if (key === directory) return item
+              }
+            })()
+          }
+
+          const clean = (target: string) =>
+            fs
+              .rm(target, {
+                recursive: true,
+                force: true,
+                maxRetries: 5,
+                retryDelay: 100,
+              })
+              .catch((error) => {
+                const message = error instanceof Error ? error.message : String(error)
+                throw new RemoveFailedError({ message: message || "Failed to remove git worktree directory" })
+              })
+
+          const stop = async (target: string) => {
+            if (!(await exists(target))) return
+            await git(["fsmonitor--daemon", "stop"], { cwd: target })
+          }
+
+          const list = await git(["worktree", "list", "--porcelain"], { cwd: instance.worktree })
+          if (list.exitCode !== 0) {
+            throw new RemoveFailedError({ message: errorText(list) || "Failed to read git worktrees" })
+          }
+
+          const entry = await locate(list.stdout)
+
+          if (!entry?.path) {
+            const directoryExists = await exists(directory)
+            if (directoryExists) {
+              await stop(directory)
+              await clean(directory)
+            }
+            return true
+          }
+
+          await stop(entry.path)
+          const removed = await git(["worktree", "remove", "--force", entry.path], {
+            cwd: instance.worktree,
+          })
+          if (removed.exitCode !== 0) {
+            const next = await git(["worktree", "list", "--porcelain"], { cwd: instance.worktree })
+            if (next.exitCode !== 0) {
+              throw new RemoveFailedError({
+                message: errorText(removed) || errorText(next) || "Failed to remove git worktree",
+              })
+            }
+
+            const stale = await locate(next.stdout)
+            if (stale?.path) {
+              throw new RemoveFailedError({ message: errorText(removed) || "Failed to remove git worktree" })
+            }
+          }
+
+          await clean(entry.path)
+
+          const branch = entry.branch?.replace(/^refs\/heads\//, "")
+          if (branch) {
+            const deleted = await git(["branch", "-D", branch], { cwd: instance.worktree })
+            if (deleted.exitCode !== 0) {
+              throw new RemoveFailedError({ message: errorText(deleted) || "Failed to delete worktree branch" })
+            }
+          }
+
+          return true
+        })
+      })
+
+      const resetEffect = Effect.fn("Worktree.reset")(function* (input: ResetInput) {
+        return yield* Effect.promise(async () => {
+          const parsed = ResetInput.parse(input)
+          if (instance.project.vcs !== "git") {
+            throw new NotGitError({ message: "Worktrees are only supported for git projects" })
+          }
+
+          const directory = await canonical(parsed.directory)
+          const primary = await canonical(instance.worktree)
+          if (directory === primary) {
+            throw new ResetFailedError({ message: "Cannot reset the primary workspace" })
+          }
+
+          const list = await git(["worktree", "list", "--porcelain"], { cwd: instance.worktree })
+          if (list.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(list) || "Failed to read git worktrees" })
+          }
+
+          const lines = outputText(list.stdout)
+            .split("\n")
+            .map((line) => line.trim())
+          const entries = lines.reduce<{ path?: string; branch?: string }[]>((acc, line) => {
+            if (!line) return acc
+            if (line.startsWith("worktree ")) {
+              acc.push({ path: line.slice("worktree ".length).trim() })
+              return acc
+            }
+            const current = acc[acc.length - 1]
+            if (!current) return acc
+            if (line.startsWith("branch ")) {
+              current.branch = line.slice("branch ".length).trim()
+            }
+            return acc
+          }, [])
+
+          const entry = await (async () => {
+            for (const item of entries) {
+              if (!item.path) continue
+              const key = await canonical(item.path)
+              if (key === directory) return item
+            }
+          })()
+          if (!entry?.path) {
+            throw new ResetFailedError({ message: "Worktree not found" })
+          }
+
+          const remoteList = await git(["remote"], { cwd: instance.worktree })
+          if (remoteList.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(remoteList) || "Failed to list git remotes" })
+          }
+
+          const remotes = outputText(remoteList.stdout)
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+
+          const remote = remotes.includes("origin")
+            ? "origin"
+            : remotes.length === 1
+              ? remotes[0]
+              : remotes.includes("upstream")
+                ? "upstream"
+                : ""
+
+          const remoteHead = remote
+            ? await git(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd: instance.worktree })
+            : { exitCode: 1, stdout: undefined, stderr: undefined }
+
+          const remoteRef = remoteHead.exitCode === 0 ? outputText(remoteHead.stdout) : ""
+          const remoteTarget = remoteRef ? remoteRef.replace(/^refs\/remotes\//, "") : ""
+          const remoteBranch =
+            remote && remoteTarget.startsWith(`${remote}/`) ? remoteTarget.slice(`${remote}/`.length) : ""
+
+          const mainCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/main"], {
+            cwd: instance.worktree,
+          })
+          const masterCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/master"], {
+            cwd: instance.worktree,
+          })
+          const localBranch = mainCheck.exitCode === 0 ? "main" : masterCheck.exitCode === 0 ? "master" : ""
+
+          const target = remoteBranch ? `${remote}/${remoteBranch}` : localBranch
+          if (!target) {
+            throw new ResetFailedError({ message: "Default branch not found" })
+          }
+
+          if (remoteBranch) {
+            const fetch = await git(["fetch", remote, remoteBranch], { cwd: instance.worktree })
+            if (fetch.exitCode !== 0) {
+              throw new ResetFailedError({ message: errorText(fetch) || `Failed to fetch ${target}` })
+            }
+          }
+
+          if (!entry.path) {
+            throw new ResetFailedError({ message: "Worktree path not found" })
+          }
+
+          const worktreePath = entry.path
+
+          const resetToTarget = await git(["reset", "--hard", target], { cwd: worktreePath })
+          if (resetToTarget.exitCode !== 0) {
+            throw new ResetFailedError({
+              message: errorText(resetToTarget) || "Failed to reset worktree to target",
+            })
+          }
+
+          const cleanResult = await sweep(worktreePath)
+          if (cleanResult.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(cleanResult) || "Failed to clean worktree" })
+          }
+
+          const update = await git(["submodule", "update", "--init", "--recursive", "--force"], {
+            cwd: worktreePath,
+          })
+          if (update.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(update) || "Failed to update submodules" })
+          }
+
+          const subReset = await git(["submodule", "foreach", "--recursive", "git", "reset", "--hard"], {
+            cwd: worktreePath,
+          })
+          if (subReset.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(subReset) || "Failed to reset submodules" })
+          }
+
+          const subClean = await git(["submodule", "foreach", "--recursive", "git", "clean", "-fdx"], {
+            cwd: worktreePath,
+          })
+          if (subClean.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(subClean) || "Failed to clean submodules" })
+          }
+
+          const status = await git(["-c", "core.fsmonitor=false", "status", "--porcelain=v1"], { cwd: worktreePath })
+          if (status.exitCode !== 0) {
+            throw new ResetFailedError({ message: errorText(status) || "Failed to read git status" })
+          }
+
+          const dirty = outputText(status.stdout)
+          if (dirty) {
+            throw new ResetFailedError({ message: `Worktree reset left local changes:\n${dirty}` })
+          }
+
+          const projectID = instance.project.id
+          queueStartScripts(worktreePath, { projectID })
+
+          return true
+        })
+      })
+
+      return Service.of({
+        makeWorktreeInfo: makeWorktreeInfoEffect,
+        createFromInfo: createFromInfoEffect,
+        create: createEffect,
+        remove: removeEffect,
+        reset: resetEffect,
+      })
+    }),
+  )
+
+  // ---------------------------------------------------------------------------
+  // Promise facades
+  // ---------------------------------------------------------------------------
+
   export async function makeWorktreeInfo(name?: string): Promise<Info> {
-    if (Instance.project.vcs !== "git") {
-      throw new NotGitError({ message: "Worktrees are only supported for git projects" })
-    }
-
-    const root = path.join(Global.Path.data, "worktree", Instance.project.id)
-    await fs.mkdir(root, { recursive: true })
-
-    const base = name ? slug(name) : ""
-    return candidate(root, base || undefined)
+    return runPromiseInstance(Service.use((svc) => svc.makeWorktreeInfo(name)))
   }
 
   export async function createFromInfo(info: Info, startCommand?: string) {
-    const created = await git(["worktree", "add", "--no-checkout", "-b", info.branch, info.directory], {
-      cwd: Instance.worktree,
-    })
-    if (created.exitCode !== 0) {
-      throw new CreateFailedError({ message: errorText(created) || "Failed to create git worktree" })
-    }
-
-    await Project.addSandbox(Instance.project.id, info.directory).catch(() => undefined)
-
-    const projectID = Instance.project.id
-    const extra = startCommand?.trim()
-
-    return () => {
-      const start = async () => {
-        const populated = await git(["reset", "--hard"], { cwd: info.directory })
-        if (populated.exitCode !== 0) {
-          const message = errorText(populated) || "Failed to populate worktree"
-          log.error("worktree checkout failed", { directory: info.directory, message })
-          GlobalBus.emit("event", {
-            directory: info.directory,
-            payload: {
-              type: Event.Failed.type,
-              properties: {
-                message,
-              },
-            },
-          })
-          return
-        }
-
-        const booted = await Instance.provide({
-          directory: info.directory,
-          init: InstanceBootstrap,
-          fn: () => undefined,
-        })
-          .then(() => true)
-          .catch((error) => {
-            const message = error instanceof Error ? error.message : String(error)
-            log.error("worktree bootstrap failed", { directory: info.directory, message })
-            GlobalBus.emit("event", {
-              directory: info.directory,
-              payload: {
-                type: Event.Failed.type,
-                properties: {
-                  message,
-                },
-              },
-            })
-            return false
-          })
-        if (!booted) return
-
-        GlobalBus.emit("event", {
-          directory: info.directory,
-          payload: {
-            type: Event.Ready.type,
-            properties: {
-              name: info.name,
-              branch: info.branch,
-            },
-          },
-        })
-
-        await runStartScripts(info.directory, { projectID, extra })
-      }
-
-      return start().catch((error) => {
-        log.error("worktree start task failed", { directory: info.directory, error })
-      })
-    }
+    return runPromiseInstance(Service.use((svc) => svc.createFromInfo(info, startCommand)))
   }
 
-  export const create = fn(CreateInput.optional(), async (input) => {
-    const info = await makeWorktreeInfo(input?.name)
-    const bootstrap = await createFromInfo(info, input?.startCommand)
-    // This is needed due to how worktrees currently work in the
-    // desktop app
-    setTimeout(() => {
-      bootstrap()
-    }, 0)
-    return info
-  })
+  export const create = Object.assign(
+    async (input?: CreateInput) => {
+      return runPromiseInstance(Service.use((svc) => svc.create(input)))
+    },
+    { schema: CreateInput.optional() },
+  )
 
-  export const remove = fn(RemoveInput, async (input) => {
-    if (Instance.project.vcs !== "git") {
-      throw new NotGitError({ message: "Worktrees are only supported for git projects" })
-    }
+  export const remove = Object.assign(
+    async (input: RemoveInput) => {
+      return runPromiseInstance(Service.use((svc) => svc.remove(input)))
+    },
+    { schema: RemoveInput },
+  )
 
-    const directory = await canonical(input.directory)
-    const locate = async (stdout: Uint8Array | undefined) => {
-      const lines = outputText(stdout)
-        .split("\n")
-        .map((line) => line.trim())
-      const entries = lines.reduce<{ path?: string; branch?: string }[]>((acc, line) => {
-        if (!line) return acc
-        if (line.startsWith("worktree ")) {
-          acc.push({ path: line.slice("worktree ".length).trim() })
-          return acc
-        }
-        const current = acc[acc.length - 1]
-        if (!current) return acc
-        if (line.startsWith("branch ")) {
-          current.branch = line.slice("branch ".length).trim()
-        }
-        return acc
-      }, [])
-
-      return (async () => {
-        for (const item of entries) {
-          if (!item.path) continue
-          const key = await canonical(item.path)
-          if (key === directory) return item
-        }
-      })()
-    }
-
-    const clean = (target: string) =>
-      fs
-        .rm(target, {
-          recursive: true,
-          force: true,
-          maxRetries: 5,
-          retryDelay: 100,
-        })
-        .catch((error) => {
-          const message = error instanceof Error ? error.message : String(error)
-          throw new RemoveFailedError({ message: message || "Failed to remove git worktree directory" })
-        })
-
-    const stop = async (target: string) => {
-      if (!(await exists(target))) return
-      await git(["fsmonitor--daemon", "stop"], { cwd: target })
-    }
-
-    const list = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
-    if (list.exitCode !== 0) {
-      throw new RemoveFailedError({ message: errorText(list) || "Failed to read git worktrees" })
-    }
-
-    const entry = await locate(list.stdout)
-
-    if (!entry?.path) {
-      const directoryExists = await exists(directory)
-      if (directoryExists) {
-        await stop(directory)
-        await clean(directory)
-      }
-      return true
-    }
-
-    await stop(entry.path)
-    const removed = await git(["worktree", "remove", "--force", entry.path], {
-      cwd: Instance.worktree,
-    })
-    if (removed.exitCode !== 0) {
-      const next = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
-      if (next.exitCode !== 0) {
-        throw new RemoveFailedError({
-          message: errorText(removed) || errorText(next) || "Failed to remove git worktree",
-        })
-      }
-
-      const stale = await locate(next.stdout)
-      if (stale?.path) {
-        throw new RemoveFailedError({ message: errorText(removed) || "Failed to remove git worktree" })
-      }
-    }
-
-    await clean(entry.path)
-
-    const branch = entry.branch?.replace(/^refs\/heads\//, "")
-    if (branch) {
-      const deleted = await git(["branch", "-D", branch], { cwd: Instance.worktree })
-      if (deleted.exitCode !== 0) {
-        throw new RemoveFailedError({ message: errorText(deleted) || "Failed to delete worktree branch" })
-      }
-    }
-
-    return true
-  })
-
-  export const reset = fn(ResetInput, async (input) => {
-    if (Instance.project.vcs !== "git") {
-      throw new NotGitError({ message: "Worktrees are only supported for git projects" })
-    }
-
-    const directory = await canonical(input.directory)
-    const primary = await canonical(Instance.worktree)
-    if (directory === primary) {
-      throw new ResetFailedError({ message: "Cannot reset the primary workspace" })
-    }
-
-    const list = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
-    if (list.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(list) || "Failed to read git worktrees" })
-    }
-
-    const lines = outputText(list.stdout)
-      .split("\n")
-      .map((line) => line.trim())
-    const entries = lines.reduce<{ path?: string; branch?: string }[]>((acc, line) => {
-      if (!line) return acc
-      if (line.startsWith("worktree ")) {
-        acc.push({ path: line.slice("worktree ".length).trim() })
-        return acc
-      }
-      const current = acc[acc.length - 1]
-      if (!current) return acc
-      if (line.startsWith("branch ")) {
-        current.branch = line.slice("branch ".length).trim()
-      }
-      return acc
-    }, [])
-
-    const entry = await (async () => {
-      for (const item of entries) {
-        if (!item.path) continue
-        const key = await canonical(item.path)
-        if (key === directory) return item
-      }
-    })()
-    if (!entry?.path) {
-      throw new ResetFailedError({ message: "Worktree not found" })
-    }
-
-    const remoteList = await git(["remote"], { cwd: Instance.worktree })
-    if (remoteList.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(remoteList) || "Failed to list git remotes" })
-    }
-
-    const remotes = outputText(remoteList.stdout)
-      .split("\n")
-      .map((line) => line.trim())
-      .filter(Boolean)
-
-    const remote = remotes.includes("origin")
-      ? "origin"
-      : remotes.length === 1
-        ? remotes[0]
-        : remotes.includes("upstream")
-          ? "upstream"
-          : ""
-
-    const remoteHead = remote
-      ? await git(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd: Instance.worktree })
-      : { exitCode: 1, stdout: undefined, stderr: undefined }
-
-    const remoteRef = remoteHead.exitCode === 0 ? outputText(remoteHead.stdout) : ""
-    const remoteTarget = remoteRef ? remoteRef.replace(/^refs\/remotes\//, "") : ""
-    const remoteBranch = remote && remoteTarget.startsWith(`${remote}/`) ? remoteTarget.slice(`${remote}/`.length) : ""
-
-    const mainCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/main"], {
-      cwd: Instance.worktree,
-    })
-    const masterCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/master"], {
-      cwd: Instance.worktree,
-    })
-    const localBranch = mainCheck.exitCode === 0 ? "main" : masterCheck.exitCode === 0 ? "master" : ""
-
-    const target = remoteBranch ? `${remote}/${remoteBranch}` : localBranch
-    if (!target) {
-      throw new ResetFailedError({ message: "Default branch not found" })
-    }
-
-    if (remoteBranch) {
-      const fetch = await git(["fetch", remote, remoteBranch], { cwd: Instance.worktree })
-      if (fetch.exitCode !== 0) {
-        throw new ResetFailedError({ message: errorText(fetch) || `Failed to fetch ${target}` })
-      }
-    }
-
-    if (!entry.path) {
-      throw new ResetFailedError({ message: "Worktree path not found" })
-    }
-
-    const worktreePath = entry.path
-
-    const resetToTarget = await git(["reset", "--hard", target], { cwd: worktreePath })
-    if (resetToTarget.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(resetToTarget) || "Failed to reset worktree to target" })
-    }
-
-    const clean = await sweep(worktreePath)
-    if (clean.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(clean) || "Failed to clean worktree" })
-    }
-
-    const update = await git(["submodule", "update", "--init", "--recursive", "--force"], { cwd: worktreePath })
-    if (update.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(update) || "Failed to update submodules" })
-    }
-
-    const subReset = await git(["submodule", "foreach", "--recursive", "git", "reset", "--hard"], {
-      cwd: worktreePath,
-    })
-    if (subReset.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(subReset) || "Failed to reset submodules" })
-    }
-
-    const subClean = await git(["submodule", "foreach", "--recursive", "git", "clean", "-fdx"], {
-      cwd: worktreePath,
-    })
-    if (subClean.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(subClean) || "Failed to clean submodules" })
-    }
-
-    const status = await git(["-c", "core.fsmonitor=false", "status", "--porcelain=v1"], { cwd: worktreePath })
-    if (status.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(status) || "Failed to read git status" })
-    }
-
-    const dirty = outputText(status.stdout)
-    if (dirty) {
-      throw new ResetFailedError({ message: `Worktree reset left local changes:\n${dirty}` })
-    }
-
-    const projectID = Instance.project.id
-    queueStartScripts(worktreePath, { projectID })
-
-    return true
-  })
+  export const reset = Object.assign(
+    async (input: ResetInput) => {
+      return runPromiseInstance(Service.use((svc) => svc.reset(input)))
+    },
+    { schema: ResetInput },
+  )
 }

packages/opencode/test/file/watcher.test.ts

@@ -5,9 +5,9 @@ import path from "path"
 import { Deferred, Effect, Option } from "effect"
 import { tmpdir } from "../fixture/fixture"
 import { watcherConfigLayer, withServices } from "../fixture/instance"
-import { Bus } from "../../src/bus"
 import { FileWatcher } from "../../src/file/watcher"
 import { Instance } from "../../src/project/instance"
+import { GlobalBus } from "../../src/bus/global"
 
 // Native @parcel/watcher bindings aren't reliably available in CI (missing on Linux, flaky on Windows)
 const describeWatcher = FileWatcher.hasNativeBinding() && !process.env.CI ? describe : describe.skip
@@ -16,6 +16,7 @@ const describeWatcher = FileWatcher.hasNativeBinding() && !process.env.CI ? desc
 // Helpers
 // ---------------------------------------------------------------------------
 
+type BusUpdate = { directory?: string; payload: { type: string; properties: WatcherEvent } }
 type WatcherEvent = { file: string; event: "add" | "change" | "unlink" }
 
 /** Run `body` with a live FileWatcher service. */
@@ -35,17 +36,22 @@ function withWatcher<E>(directory: string, body: Effect.Effect<void, E>) {
 function listen(directory: string, check: (evt: WatcherEvent) => boolean, hit: (evt: WatcherEvent) => void) {
   let done = false
 
-  const unsub = Bus.subscribe(FileWatcher.Event.Updated, (evt) => {
+  function on(evt: BusUpdate) {
     if (done) return
-    if (!check(evt.properties)) return
-    hit(evt.properties)
-  })
+    if (evt.directory !== directory) return
+    if (evt.payload.type !== FileWatcher.Event.Updated.type) return
+    if (!check(evt.payload.properties)) return
+    hit(evt.payload.properties)
+  }
 
-  return () => {
+  function cleanup() {
     if (done) return
     done = true
-    unsub()
+    GlobalBus.off("event", on)
   }
+
+  GlobalBus.on("event", on)
+  return cleanup
 }
 
 function wait(directory: string, check: (evt: WatcherEvent) => boolean) {