fix: refresh Worktree service per instance

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

@@ -129,7 +129,7 @@ Still open and likely worth migrating:
 - [ ] `Plugin`
 - [ ] `ToolRegistry`
 - [ ] `Pty`
-- [ ] `Worktree`
+- [x] `Worktree`
 - [ ] `Installation`
 - [ ] `Bus`
 - [ ] `Command`

packages/opencode/src/effect/instances.ts

@@ -10,6 +10,7 @@ import { ProviderAuth } from "@/provider/auth-service"
 import { Question } from "@/question/service"
 import { Skill } from "@/skill/service"
 import { Snapshot } from "@/snapshot/service"
+import { Worktree } from "@/worktree"
 import { InstanceContext } from "./instance-context"
 import { registerDisposer } from "./instance-registry"
 
@@ -26,6 +27,7 @@ export type InstanceServices =
   | File.Service
   | Skill.Service
   | Snapshot.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
@@ -46,6 +48,7 @@ function lookup(_key: string) {
     File.layer,
     Skill.defaultLayer,
     Snapshot.defaultLayer,
+    Worktree.layer,
   ).pipe(Layer.provide(ctx))
 }
 

packages/opencode/src/worktree/index.ts

@@ -4,17 +4,17 @@ import z from "zod"
 import { NamedError } from "@opencode-ai/util/error"
 import { Global } from "../global"
 import { Instance } from "../project/instance"
-import { InstanceBootstrap } from "../project/bootstrap"
 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 { Effect, Layer, ServiceMap } from "effect"
 
 export namespace Worktree {
   const log = Log.create({ service: "worktree" })
@@ -267,7 +267,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 +277,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,29 +335,51 @@ export namespace Worktree {
     }, 0)
   }
 
-  export async function makeWorktreeInfo(name?: string): Promise<Info> {
+  // ---------------------------------------------------------------------------
-    if (Instance.project.vcs !== "git") {
+  // 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)
+          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 candidateName(instance.worktree, root, base || undefined)
-  }
+        })
+      })
 
-  export async function createFromInfo(info: Info, startCommand?: string) {
+      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,
+            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)
+          await Project.addSandbox(instance.project.id, info.directory).catch(() => undefined)
 
-    const projectID = Instance.project.id
+          const projectID = instance.project.id
           const extra = startCommand?.trim()
 
           return () => {
@@ -380,7 +402,10 @@ export namespace Worktree {
 
               const booted = await Instance.provide({
                 directory: info.directory,
-          init: InstanceBootstrap,
+                init: async () => {
+                  const { InstanceBootstrap } = await import("../project/bootstrap")
+                  return InstanceBootstrap()
+                },
                 fn: () => undefined,
               })
                 .then(() => true)
@@ -418,11 +443,13 @@ export namespace Worktree {
               log.error("worktree start task failed", { directory: info.directory, error })
             })
           }
-  }
+        })
+      })
 
-  export const create = fn(CreateInput.optional(), async (input) => {
+      const createEffect = Effect.fn("Worktree.create")(function* (input?: CreateInput) {
-    const info = await makeWorktreeInfo(input?.name)
+        const parsed = input ? CreateInput.optional().parse(input) : undefined
-    const bootstrap = await createFromInfo(info, input?.startCommand)
+        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(() => {
@@ -431,12 +458,14 @@ export namespace Worktree {
         return info
       })
 
-  export const remove = fn(RemoveInput, async (input) => {
+      const removeEffect = Effect.fn("Worktree.remove")(function* (input: RemoveInput) {
-    if (Instance.project.vcs !== "git") {
+        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(input.directory)
+          const directory = await canonical(parsed.directory)
           const locate = async (stdout: Uint8Array | undefined) => {
             const lines = outputText(stdout)
               .split("\n")
@@ -482,7 +511,7 @@ export namespace Worktree {
             await git(["fsmonitor--daemon", "stop"], { cwd: target })
           }
 
-    const list = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
+          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" })
           }
@@ -500,10 +529,10 @@ export namespace Worktree {
 
           await stop(entry.path)
           const removed = await git(["worktree", "remove", "--force", entry.path], {
-      cwd: Instance.worktree,
+            cwd: instance.worktree,
           })
           if (removed.exitCode !== 0) {
-      const next = await git(["worktree", "list", "--porcelain"], { cwd: Instance.worktree })
+            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",
@@ -520,7 +549,7 @@ export namespace Worktree {
 
           const branch = entry.branch?.replace(/^refs\/heads\//, "")
           if (branch) {
-      const deleted = await git(["branch", "-D", branch], { cwd: Instance.worktree })
+            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" })
             }
@@ -528,19 +557,22 @@ export namespace Worktree {
 
           return true
         })
+      })
 
-  export const reset = fn(ResetInput, async (input) => {
+      const resetEffect = Effect.fn("Worktree.reset")(function* (input: ResetInput) {
-    if (Instance.project.vcs !== "git") {
+        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(input.directory)
+          const directory = await canonical(parsed.directory)
-    const primary = await canonical(Instance.worktree)
+          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 })
+          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" })
           }
@@ -573,7 +605,7 @@ export namespace Worktree {
             throw new ResetFailedError({ message: "Worktree not found" })
           }
 
-    const remoteList = await git(["remote"], { cwd: Instance.worktree })
+          const remoteList = await git(["remote"], { cwd: instance.worktree })
           if (remoteList.exitCode !== 0) {
             throw new ResetFailedError({ message: errorText(remoteList) || "Failed to list git remotes" })
           }
@@ -592,18 +624,19 @@ export namespace Worktree {
                 : ""
 
           const remoteHead = remote
-      ? await git(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd: Instance.worktree })
+            ? 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 remoteBranch =
+            remote && remoteTarget.startsWith(`${remote}/`) ? remoteTarget.slice(`${remote}/`.length) : ""
 
           const mainCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/main"], {
-      cwd: Instance.worktree,
+            cwd: instance.worktree,
           })
           const masterCheck = await git(["show-ref", "--verify", "--quiet", "refs/heads/master"], {
-      cwd: Instance.worktree,
+            cwd: instance.worktree,
           })
           const localBranch = mainCheck.exitCode === 0 ? "main" : masterCheck.exitCode === 0 ? "master" : ""
 
@@ -613,7 +646,7 @@ export namespace Worktree {
           }
 
           if (remoteBranch) {
-      const fetch = await git(["fetch", remote, remoteBranch], { cwd: Instance.worktree })
+            const fetch = await git(["fetch", remote, remoteBranch], { cwd: instance.worktree })
             if (fetch.exitCode !== 0) {
               throw new ResetFailedError({ message: errorText(fetch) || `Failed to fetch ${target}` })
             }
@@ -627,15 +660,19 @@ export namespace Worktree {
 
           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" })
+            throw new ResetFailedError({
+              message: errorText(resetToTarget) || "Failed to reset worktree to target",
+            })
           }
 
-    const clean = await sweep(worktreePath)
+          const cleanResult = await sweep(worktreePath)
-    if (clean.exitCode !== 0) {
+          if (cleanResult.exitCode !== 0) {
-      throw new ResetFailedError({ message: errorText(clean) || "Failed to clean worktree" })
+            throw new ResetFailedError({ message: errorText(cleanResult) || "Failed to clean worktree" })
           }
 
-    const update = await git(["submodule", "update", "--init", "--recursive", "--force"], { cwd: worktreePath })
+          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" })
           }
@@ -664,9 +701,58 @@ export namespace Worktree {
             throw new ResetFailedError({ message: `Worktree reset left local changes:\n${dirty}` })
           }
 
-    const projectID = Instance.project.id
+          const projectID = instance.project.id
           queueStartScripts(worktreePath, { projectID })
 
           return true
         })
+      })
+
+      return Service.of({
+        makeWorktreeInfo: makeWorktreeInfoEffect,
+        createFromInfo: createFromInfoEffect,
+        create: createEffect,
+        remove: removeEffect,
+        reset: resetEffect,
+      })
+    }),
+  ).pipe(Layer.fresh)
+
+  async function run<A, E>(effect: Effect.Effect<A, E, Service>) {
+    const { runPromiseInstance } = await import("@/effect/runtime")
+    return runPromiseInstance(effect)
+  }
+
+  // ---------------------------------------------------------------------------
+  // Promise facades
+  // ---------------------------------------------------------------------------
+
+  export async function makeWorktreeInfo(name?: string): Promise<Info> {
+    return run(Service.use((svc) => svc.makeWorktreeInfo(name)))
+  }
+
+  export async function createFromInfo(info: Info, startCommand?: string) {
+    return run(Service.use((svc) => svc.createFromInfo(info, startCommand)))
+  }
+
+  export const create = Object.assign(
+    async (input?: CreateInput) => {
+      return run(Service.use((svc) => svc.create(input)))
+    },
+    { schema: CreateInput.optional() },
+  )
+
+  export const remove = Object.assign(
+    async (input: RemoveInput) => {
+      return run(Service.use((svc) => svc.remove(input)))
+    },
+    { schema: RemoveInput },
+  )
+
+  export const reset = Object.assign(
+    async (input: ResetInput) => {
+      return run(Service.use((svc) => svc.reset(input)))
+    },
+    { schema: ResetInput },
+  )
 }