Merge branch 'dev' into kit/effectify-pty

packages/opencode/specs/effect-migration.md

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

packages/opencode/src/effect/instances.ts

@@ -4,13 +4,13 @@ import { FileTime } from "@/file/time-service"
 import { FileWatcher } from "@/file/watcher"
 import { Format } from "@/format/service"
 import { Permission } from "@/permission/service"
+import { Pty } from "@/pty"
 import { Instance } from "@/project/instance"
 import { Vcs } from "@/project/vcs"
 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"
 
@@ -25,9 +25,9 @@ export type InstanceServices =
   | FileTime.Service
   | Format.Service
   | File.Service
+  | Pty.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,9 +46,9 @@ function lookup(_key: string) {
     FileTime.layer,
     Format.layer,
     File.layer,
+    Pty.layer,
     Skill.defaultLayer,
     Snapshot.defaultLayer,
-    Worktree.layer,
   ).pipe(Layer.provide(ctx))
 }
 

packages/opencode/src/effect/runtime.ts

@@ -20,6 +20,10 @@ export function runPromiseInstance<A, E>(effect: Effect.Effect<A, E, InstanceSer
   return runtime.runPromise(effect.pipe(Effect.provide(Instances.get(Instance.directory))))
 }
 
+export function runSyncInstance<A, E>(effect: Effect.Effect<A, E, InstanceServices>) {
+  return runtime.runSync(effect.pipe(Effect.provide(Instances.get(Instance.directory))))
+}
+
 export function disposeRuntime() {
   return runtime.dispose()
 }

packages/opencode/src/pty/index.ts

@@ -1,13 +1,12 @@
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
+import { InstanceContext } from "@/effect/instance-context"
 import { type IPty } from "bun-pty"
 import z from "zod"
 import { Log } from "../util/log"
-import { Instance } from "../project/instance"
 import { lazy } from "@opencode-ai/util/lazy"
-import { Shell } from "@/shell/shell"
-import { Plugin } from "@/plugin"
 import { PtyID } from "./schema"
+import { Effect, Layer, ServiceMap } from "effect"
 
 export namespace Pty {
   const log = Log.create({ service: "pty" })
@@ -90,232 +89,297 @@ export namespace Pty {
     subscribers: Map<unknown, Socket>
   }
 
-  const state = Instance.state(
-    () => new Map<PtyID, ActiveSession>(),
-    async (sessions) => {
-      for (const session of sessions.values()) {
+  export interface Interface {
+    readonly list: () => Effect.Effect<Info[]>
+    readonly get: (id: PtyID) => Effect.Effect<Info | undefined>
+    readonly create: (input: CreateInput) => Effect.Effect<Info>
+    readonly update: (id: PtyID, input: UpdateInput) => Effect.Effect<Info | undefined>
+    readonly remove: (id: PtyID) => Effect.Effect<void>
+    readonly resize: (id: PtyID, cols: number, rows: number) => Effect.Effect<void>
+    readonly write: (id: PtyID, data: string) => Effect.Effect<void>
+    readonly connect: (
+      id: PtyID,
+      ws: Socket,
+      cursor?: number,
+    ) => Effect.Effect<{ onMessage: (message: string | ArrayBuffer) => void; onClose: () => void } | undefined>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Pty") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const instance = yield* InstanceContext
+      const sessions = new Map<PtyID, ActiveSession>()
+
+      yield* Effect.addFinalizer(() =>
+        Effect.sync(() => {
+          for (const session of sessions.values()) {
+            try {
+              session.process.kill()
+            } catch {}
+            for (const [key, ws] of session.subscribers.entries()) {
+              try {
+                if (ws.data === key) ws.close()
+              } catch {}
+            }
+          }
+          sessions.clear()
+        }),
+      )
+
+      const removeSession = (id: PtyID) => {
+        const session = sessions.get(id)
+        if (!session) return
+        sessions.delete(id)
+        log.info("removing session", { id })
         try {
           session.process.kill()
         } catch {}
         for (const [key, ws] of session.subscribers.entries()) {
           try {
             if (ws.data === key) ws.close()
+          } catch {}
+        }
+        session.subscribers.clear()
+        Bus.publish(Event.Deleted, { id: session.info.id })
+      }
+
+      const list = Effect.fn("Pty.list")(function* () {
+        return Array.from(sessions.values()).map((s) => s.info)
+      })
+
+      const get = Effect.fn("Pty.get")(function* (id: PtyID) {
+        return sessions.get(id)?.info
+      })
+
+      const create = Effect.fn("Pty.create")(function* (input: CreateInput) {
+        return yield* Effect.promise(async () => {
+          const [{ Shell }, { Plugin }] = await Promise.all([import("@/shell/shell"), import("@/plugin")])
+          const id = PtyID.ascending()
+          const command = input.command || Shell.preferred()
+          const args = input.args || []
+          if (command.endsWith("sh")) {
+            args.push("-l")
+          }
+
+          const cwd = input.cwd || instance.directory
+          const shellEnv = await Plugin.trigger("shell.env", { cwd }, { env: {} })
+          const env = {
+            ...process.env,
+            ...input.env,
+            ...shellEnv.env,
+            TERM: "xterm-256color",
+            OPENCODE_TERMINAL: "1",
+          } as Record<string, string>
+
+          if (process.platform === "win32") {
+            env.LC_ALL = "C.UTF-8"
+            env.LC_CTYPE = "C.UTF-8"
+            env.LANG = "C.UTF-8"
+          }
+          log.info("creating session", { id, cmd: command, args, cwd })
+
+          const spawn = await pty()
+          const ptyProcess = spawn(command, args, {
+            name: "xterm-256color",
+            cwd,
+            env,
+          })
+
+          const info = {
+            id,
+            title: input.title || `Terminal ${id.slice(-4)}`,
+            command,
+            args,
+            cwd,
+            status: "running",
+            pid: ptyProcess.pid,
+          } as const
+          const session: ActiveSession = {
+            info,
+            process: ptyProcess,
+            buffer: "",
+            bufferCursor: 0,
+            cursor: 0,
+            subscribers: new Map(),
+          }
+          sessions.set(id, session)
+          ptyProcess.onData((chunk) => {
+            session.cursor += chunk.length
+
+            for (const [key, ws] of session.subscribers.entries()) {
+              if (ws.readyState !== 1) {
+                session.subscribers.delete(key)
+                continue
+              }
+              if (ws.data !== key) {
+                session.subscribers.delete(key)
+                continue
+              }
+              try {
+                ws.send(chunk)
+              } catch {
+                session.subscribers.delete(key)
+              }
+            }
+
+            session.buffer += chunk
+            if (session.buffer.length <= BUFFER_LIMIT) return
+            const excess = session.buffer.length - BUFFER_LIMIT
+            session.buffer = session.buffer.slice(excess)
+            session.bufferCursor += excess
+          })
+          ptyProcess.onExit(({ exitCode }) => {
+            if (session.info.status === "exited") return
+            log.info("session exited", { id, exitCode })
+            session.info.status = "exited"
+            Bus.publish(Event.Exited, { id, exitCode })
+            removeSession(id)
+          })
+          Bus.publish(Event.Created, { info })
+          return info
+        })
+      })
+
+      const update = Effect.fn("Pty.update")(function* (id: PtyID, input: UpdateInput) {
+        const session = sessions.get(id)
+        if (!session) return
+        if (input.title) {
+          session.info.title = input.title
+        }
+        if (input.size) {
+          session.process.resize(input.size.cols, input.size.rows)
+        }
+        Bus.publish(Event.Updated, { info: session.info })
+        return session.info
+      })
+
+      const remove = Effect.fn("Pty.remove")(function* (id: PtyID) {
+        removeSession(id)
+      })
+
+      const resize = Effect.fn("Pty.resize")(function* (id: PtyID, cols: number, rows: number) {
+        const session = sessions.get(id)
+        if (session && session.info.status === "running") {
+          session.process.resize(cols, rows)
+        }
+      })
+
+      const write = Effect.fn("Pty.write")(function* (id: PtyID, data: string) {
+        const session = sessions.get(id)
+        if (session && session.info.status === "running") {
+          session.process.write(data)
+        }
+      })
+
+      const connect = Effect.fn("Pty.connect")(function* (id: PtyID, ws: Socket, cursor?: number) {
+        const session = sessions.get(id)
+        if (!session) {
+          ws.close()
+          return
+        }
+        log.info("client connected to session", { id })
+
+        const connectionKey = ws.data && typeof ws.data === "object" ? ws.data : ws
+        session.subscribers.delete(connectionKey)
+        session.subscribers.set(connectionKey, ws)
+
+        const cleanup = () => {
+          session.subscribers.delete(connectionKey)
+        }
+
+        const start = session.bufferCursor
+        const end = session.cursor
+
+        const from =
+          cursor === -1 ? end : typeof cursor === "number" && Number.isSafeInteger(cursor) ? Math.max(0, cursor) : 0
+
+        const data = (() => {
+          if (!session.buffer) return ""
+          if (from >= end) return ""
+          const offset = Math.max(0, from - start)
+          if (offset >= session.buffer.length) return ""
+          return session.buffer.slice(offset)
+        })()
+
+        if (data) {
+          try {
+            for (let i = 0; i < data.length; i += BUFFER_CHUNK) {
+              ws.send(data.slice(i, i + BUFFER_CHUNK))
+            }
           } catch {
-            // ignore
+            cleanup()
+            ws.close()
+            return
           }
         }
-      }
-      sessions.clear()
-    },
+
+        try {
+          ws.send(meta(end))
+        } catch {
+          cleanup()
+          ws.close()
+          return
+        }
+        return {
+          onMessage: (message: string | ArrayBuffer) => {
+            session.process.write(String(message))
+          },
+          onClose: () => {
+            log.info("client disconnected from session", { id })
+            cleanup()
+          },
+        }
+      })
+
+      return Service.of({ list, get, create, update, remove, resize, write, connect })
+    }),
   )
 
+  function runtime() {
+    return require("@/effect/runtime") as typeof import("@/effect/runtime")
+  }
+
+  function run<A, E>(effect: Effect.Effect<A, E, Service>) {
+    return runtime().runPromiseInstance(effect)
+  }
+
+  function runSync<A, E>(effect: Effect.Effect<A, E, Service>) {
+    return runtime().runSyncInstance(effect)
+  }
+
+  // Sync facades
   export function list() {
-    return Array.from(state().values()).map((s) => s.info)
+    return runSync(Service.use((svc) => svc.list()))
   }
 
   export function get(id: PtyID) {
-    return state().get(id)?.info
-  }
-
-  export async function create(input: CreateInput) {
-    const id = PtyID.ascending()
-    const command = input.command || Shell.preferred()
-    const args = input.args || []
-    if (command.endsWith("sh")) {
-      args.push("-l")
-    }
-
-    const cwd = input.cwd || Instance.directory
-    const shellEnv = await Plugin.trigger("shell.env", { cwd }, { env: {} })
-    const env = {
-      ...process.env,
-      ...input.env,
-      ...shellEnv.env,
-      TERM: "xterm-256color",
-      OPENCODE_TERMINAL: "1",
-    } as Record<string, string>
-
-    if (process.platform === "win32") {
-      env.LC_ALL = "C.UTF-8"
-      env.LC_CTYPE = "C.UTF-8"
-      env.LANG = "C.UTF-8"
-    }
-    log.info("creating session", { id, cmd: command, args, cwd })
-
-    const spawn = await pty()
-    const ptyProcess = spawn(command, args, {
-      name: "xterm-256color",
-      cwd,
-      env,
-    })
-
-    const info = {
-      id,
-      title: input.title || `Terminal ${id.slice(-4)}`,
-      command,
-      args,
-      cwd,
-      status: "running",
-      pid: ptyProcess.pid,
-    } as const
-    const session: ActiveSession = {
-      info,
-      process: ptyProcess,
-      buffer: "",
-      bufferCursor: 0,
-      cursor: 0,
-      subscribers: new Map(),
-    }
-    state().set(id, session)
-    ptyProcess.onData(
-      Instance.bind((chunk) => {
-        session.cursor += chunk.length
-
-        for (const [key, ws] of session.subscribers.entries()) {
-          if (ws.readyState !== 1) {
-            session.subscribers.delete(key)
-            continue
-          }
-
-          if (ws.data !== key) {
-            session.subscribers.delete(key)
-            continue
-          }
-
-          try {
-            ws.send(chunk)
-          } catch {
-            session.subscribers.delete(key)
-          }
-        }
-
-        session.buffer += chunk
-        if (session.buffer.length <= BUFFER_LIMIT) return
-        const excess = session.buffer.length - BUFFER_LIMIT
-        session.buffer = session.buffer.slice(excess)
-        session.bufferCursor += excess
-      }),
-    )
-    ptyProcess.onExit(
-      Instance.bind(({ exitCode }) => {
-        if (session.info.status === "exited") return
-        log.info("session exited", { id, exitCode })
-        session.info.status = "exited"
-        Bus.publish(Event.Exited, { id, exitCode })
-        remove(id)
-      }),
-    )
-    Bus.publish(Event.Created, { info })
-    return info
-  }
-
-  export async function update(id: PtyID, input: UpdateInput) {
-    const session = state().get(id)
-    if (!session) return
-    if (input.title) {
-      session.info.title = input.title
-    }
-    if (input.size) {
-      session.process.resize(input.size.cols, input.size.rows)
-    }
-    Bus.publish(Event.Updated, { info: session.info })
-    return session.info
-  }
-
-  export async function remove(id: PtyID) {
-    const session = state().get(id)
-    if (!session) return
-    state().delete(id)
-    log.info("removing session", { id })
-    try {
-      session.process.kill()
-    } catch {}
-    for (const [key, ws] of session.subscribers.entries()) {
-      try {
-        if (ws.data === key) ws.close()
-      } catch {
-        // ignore
-      }
-    }
-    session.subscribers.clear()
-    Bus.publish(Event.Deleted, { id: session.info.id })
+    return runSync(Service.use((svc) => svc.get(id)))
   }
 
   export function resize(id: PtyID, cols: number, rows: number) {
-    const session = state().get(id)
-    if (session && session.info.status === "running") {
-      session.process.resize(cols, rows)
-    }
+    runSync(Service.use((svc) => svc.resize(id, cols, rows)))
   }
 
   export function write(id: PtyID, data: string) {
-    const session = state().get(id)
-    if (session && session.info.status === "running") {
-      session.process.write(data)
-    }
+    runSync(Service.use((svc) => svc.write(id, data)))
   }
 
   export function connect(id: PtyID, ws: Socket, cursor?: number) {
-    const session = state().get(id)
-    if (!session) {
-      ws.close()
-      return
-    }
-    log.info("client connected to session", { id })
+    return runSync(Service.use((svc) => svc.connect(id, ws, cursor)))
+  }
 
-    // Use ws.data as the unique key for this connection lifecycle.
-    // If ws.data is undefined, fallback to ws object.
-    const connectionKey = ws.data && typeof ws.data === "object" ? ws.data : ws
+  // Async facades
+  export async function create(input: CreateInput) {
+    return run(Service.use((svc) => svc.create(input)))
+  }
 
-    // Optionally cleanup if the key somehow exists
-    session.subscribers.delete(connectionKey)
-    session.subscribers.set(connectionKey, ws)
+  export async function update(id: PtyID, input: UpdateInput) {
+    return run(Service.use((svc) => svc.update(id, input)))
+  }
 
-    const cleanup = () => {
-      session.subscribers.delete(connectionKey)
-    }
-
-    const start = session.bufferCursor
-    const end = session.cursor
-
-    const from =
-      cursor === -1 ? end : typeof cursor === "number" && Number.isSafeInteger(cursor) ? Math.max(0, cursor) : 0
-
-    const data = (() => {
-      if (!session.buffer) return ""
-      if (from >= end) return ""
-      const offset = Math.max(0, from - start)
-      if (offset >= session.buffer.length) return ""
-      return session.buffer.slice(offset)
-    })()
-
-    if (data) {
-      try {
-        for (let i = 0; i < data.length; i += BUFFER_CHUNK) {
-          ws.send(data.slice(i, i + BUFFER_CHUNK))
-        }
-      } catch {
-        cleanup()
-        ws.close()
-        return
-      }
-    }
-
-    try {
-      ws.send(meta(end))
-    } catch {
-      cleanup()
-      ws.close()
-      return
-    }
-    return {
-      onMessage: (message: string | ArrayBuffer) => {
-        session.process.write(String(message))
-      },
-      onClose: () => {
-        log.info("client disconnected from session", { id })
-        cleanup()
-      },
-    }
+  export async function remove(id: PtyID) {
+    return run(Service.use((svc) => svc.remove(id)))
   }
 }

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 candidateName(worktreeDir: string, root: string, base?: string) {
+  async function candidate(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: worktreeDir,
+        cwd: Instance.worktree,
       })
       if (branchCheck.exitCode === 0) continue
 
@@ -335,424 +335,338 @@ 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: async () => {
-                  const { InstanceBootstrap } = await import("../project/bootstrap")
-                  return 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,
-      })
-    }),
-  ).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)))
+    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)
   }
 
   export async function createFromInfo(info: Info, startCommand?: string) {
-    return run(Service.use((svc) => svc.createFromInfo(info, startCommand)))
+    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 })
+      })
+    }
   }
 
-  export const create = Object.assign(
-    async (input?: CreateInput) => {
-      return run(Service.use((svc) => svc.create(input)))
-    },
-    { schema: CreateInput.optional() },
-  )
+  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 remove = Object.assign(
-    async (input: RemoveInput) => {
-      return run(Service.use((svc) => svc.remove(input)))
-    },
-    { schema: RemoveInput },
-  )
+  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 reset = Object.assign(
-    async (input: ResetInput) => {
-      return run(Service.use((svc) => svc.reset(input)))
-    },
-    { schema: ResetInput },
-  )
+    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
+  })
 }