bonecode 1.0.0 → 1.2.0

package/src/engine/worktree/index.ts

@@ -1,621 +1,621 @@
-import { Global } from "@opencode-ai/core/global"
-import { InstanceLayer } from "@/project/instance-layer"
-import { InstanceStore } from "@/project/instance-store"
-import { Project } from "@/project/project"
-import { Database } from "@/storage/db"
-import { eq } from "drizzle-orm"
-import { ProjectTable } from "../project/project.sql"
-import type { ProjectID } from "../project/schema"
-import * as Log from "@opencode-ai/core/util/log"
-import { Slug } from "@opencode-ai/core/util/slug"
-import { errorMessage } from "../util/error"
-import { BusEvent } from "@/bus/bus-event"
-import { GlobalBus } from "@/bus/global"
-import { Git } from "@/git"
-import { Effect, Layer, Path, Schema, Scope, Context } from "effect"
-import { ChildProcess } from "effect/unstable/process"
-import { NodePath } from "@effect/platform-node"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { BootstrapRuntime } from "@/effect/bootstrap-runtime"
-import { AppProcess } from "@opencode-ai/core/process"
-import { InstanceState } from "@/effect/instance-state"
-
-const log = Log.create({ service: "worktree" })
-
-export const Event = {
-  Ready: BusEvent.define(
-    "worktree.ready",
-    Schema.Struct({
-      name: Schema.String,
-      branch: Schema.optional(Schema.String),
-    }),
-  ),
-  Failed: BusEvent.define(
-    "worktree.failed",
-    Schema.Struct({
-      message: Schema.String,
-    }),
-  ),
-}
-
-export const Info = Schema.Struct({
-  name: Schema.String,
-  branch: Schema.optional(Schema.String),
-  directory: Schema.String,
-}).annotate({ identifier: "Worktree" })
-export type Info = Schema.Schema.Type<typeof Info>
-
-export const CreateInput = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  startCommand: Schema.optional(
-    Schema.String.annotate({ description: "Additional startup script to run after the project's start command" }),
-  ),
-}).annotate({ identifier: "WorktreeCreateInput" })
-export type CreateInput = Schema.Schema.Type<typeof CreateInput>
-
-export const RemoveInput = Schema.Struct({
-  directory: Schema.String,
-}).annotate({ identifier: "WorktreeRemoveInput" })
-export type RemoveInput = Schema.Schema.Type<typeof RemoveInput>
-
-export const ResetInput = Schema.Struct({
-  directory: Schema.String,
-}).annotate({ identifier: "WorktreeResetInput" })
-export type ResetInput = Schema.Schema.Type<typeof ResetInput>
-
-export class NotGitError extends Schema.TaggedErrorClass<NotGitError>()("WorktreeNotGitError", {
-  message: Schema.String,
-}) {}
-
-export class NameGenerationFailedError extends Schema.TaggedErrorClass<NameGenerationFailedError>()(
-  "WorktreeNameGenerationFailedError",
-  {
-    message: Schema.String,
-  },
-) {}
-
-export class CreateFailedError extends Schema.TaggedErrorClass<CreateFailedError>()("WorktreeCreateFailedError", {
-  message: Schema.String,
-}) {}
-
-export class StartCommandFailedError extends Schema.TaggedErrorClass<StartCommandFailedError>()(
-  "WorktreeStartCommandFailedError",
-  {
-    message: Schema.String,
-  },
-) {}
-
-export class RemoveFailedError extends Schema.TaggedErrorClass<RemoveFailedError>()("WorktreeRemoveFailedError", {
-  message: Schema.String,
-}) {}
-
-export class ResetFailedError extends Schema.TaggedErrorClass<ResetFailedError>()("WorktreeResetFailedError", {
-  message: Schema.String,
-}) {}
-
-export class ListFailedError extends Schema.TaggedErrorClass<ListFailedError>()("WorktreeListFailedError", {
-  message: Schema.String,
-}) {}
-
-export type Error =
-  | NotGitError
-  | NameGenerationFailedError
-  | CreateFailedError
-  | StartCommandFailedError
-  | RemoveFailedError
-  | ResetFailedError
-  | ListFailedError
-
-function slugify(input: string) {
-  return input
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+/, "")
-    .replace(/-+$/, "")
-}
-
-function failedRemoves(...chunks: string[]) {
-  return chunks.filter(Boolean).flatMap((chunk) =>
-    chunk
-      .split("\n")
-      .map((line) => line.trim())
-      .flatMap((line) => {
-        const match = line.match(/^warning:\s+failed to remove\s+(.+):\s+/i)
-        if (!match) return []
-        const value = match[1]?.trim().replace(/^['"]|['"]$/g, "")
-        if (!value) return []
-        return [value]
-      }),
-  )
-}
-
-// ---------------------------------------------------------------------------
-// Effect service
-// ---------------------------------------------------------------------------
-
-export interface Interface {
-  readonly makeWorktreeInfo: (options?: { name?: string; detached?: boolean }) => Effect.Effect<Info, Error>
-  readonly createFromInfo: (info: Info, startCommand?: string) => Effect.Effect<void, Error>
-  readonly create: (input?: CreateInput) => Effect.Effect<Info, Error>
-  readonly list: () => Effect.Effect<(Omit<Info, "branch"> & { branch?: string })[], Error>
-  readonly remove: (input: RemoveInput) => Effect.Effect<boolean, Error>
-  readonly reset: (input: ResetInput) => Effect.Effect<boolean, Error>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Worktree") {}
-
-type GitResult = { code: number; text: string; stderr: string }
-
-export const layer: Layer.Layer<
-  Service,
-  never,
-  AppFileSystem.Service | Path.Path | AppProcess.Service | Git.Service | Project.Service | InstanceStore.Service
-> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const scope = yield* Scope.Scope
-    const fs = yield* AppFileSystem.Service
-    const pathSvc = yield* Path.Path
-    const appProcess = yield* AppProcess.Service
-    const gitSvc = yield* Git.Service
-    const project = yield* Project.Service
-    const store = yield* InstanceStore.Service
-
-    const git = Effect.fnUntraced(
-      function* (args: string[], opts?: { cwd?: string }) {
-        const result = yield* appProcess.run(
-          ChildProcess.make("git", args, { cwd: opts?.cwd, extendEnv: true, stdin: "ignore" }),
-        )
-        return {
-          code: result.exitCode,
-          text: result.stdout.toString("utf8"),
-          stderr: result.stderr.toString("utf8"),
-        } satisfies GitResult
-      },
-      Effect.catch((e) =>
-        Effect.succeed({
-          code: 1,
-          text: "",
-          stderr: e instanceof Error ? e.message : String(e),
-        } satisfies GitResult),
-      ),
-    )
-
-    const MAX_NAME_ATTEMPTS = 26
-    const candidate = Effect.fn("Worktree.candidate")(function* (input: {
-      root: string
-      name?: string
-      detached?: boolean
-    }) {
-      const ctx = yield* InstanceState.context
-      for (const attempt of Array.from({ length: MAX_NAME_ATTEMPTS }, (_, i) => i)) {
-        const name = input.name ? (attempt === 0 ? input.name : `${input.name}-${Slug.create()}`) : Slug.create()
-        const branch = input.detached ? undefined : `opencode/${name}`
-        const directory = pathSvc.join(input.root, name)
-
-        if (yield* fs.exists(directory).pipe(Effect.orDie)) continue
-
-        if (branch) {
-          const ref = `refs/heads/${branch}`
-          const branchCheck = yield* git(["show-ref", "--verify", "--quiet", ref], { cwd: ctx.worktree })
-          if (branchCheck.code === 0) continue
-        }
-
-        return { name, directory, ...(branch ? { branch } : {}) }
-      }
-      return yield* new NameGenerationFailedError({ message: "Failed to generate a unique worktree name" })
-    })
-
-    const makeWorktreeInfo = Effect.fn("Worktree.makeWorktreeInfo")(function* (input?: {
-      name?: string
-      detached?: boolean
-    }) {
-      const ctx = yield* InstanceState.context
-      if (ctx.project.vcs !== "git") {
-        return yield* new NotGitError({ message: "Worktrees are only supported for git projects" })
-      }
-
-      const root = pathSvc.join(Global.Path.data, "worktree", ctx.project.id)
-      yield* fs.makeDirectory(root, { recursive: true }).pipe(Effect.orDie)
-
-      return yield* candidate({ root, name: input?.name ? slugify(input.name) : "", detached: input?.detached })
-    })
-
-    const setup = Effect.fnUntraced(function* (info: Info) {
-      const ctx = yield* InstanceState.context
-      const created = yield* git(
-        info.branch
-          ? ["worktree", "add", "--no-checkout", "-b", info.branch, info.directory]
-          : ["worktree", "add", "--no-checkout", "--detach", info.directory, "HEAD"],
-        { cwd: ctx.worktree },
-      )
-      if (created.code !== 0) {
-        return yield* new CreateFailedError({
-          message: created.stderr || created.text || "Failed to create git worktree",
-        })
-      }
-
-      yield* project.addSandbox(ctx.project.id, info.directory).pipe(Effect.catch(() => Effect.void))
-    })
-
-    const boot = Effect.fnUntraced(function* (info: Info, startCommand?: string) {
-      const ctx = yield* InstanceState.context
-      const workspaceID = yield* InstanceState.workspaceID
-      const projectID = ctx.project.id
-      const extra = startCommand?.trim()
-
-      const populated = yield* git(["reset", "--hard"], { cwd: info.directory })
-      if (populated.code !== 0) {
-        const message = populated.stderr || populated.text || "Failed to populate worktree"
-        log.error("worktree checkout failed", { directory: info.directory, message })
-        GlobalBus.emit("event", {
-          directory: info.directory,
-          project: ctx.project.id,
-          workspace: workspaceID,
-          payload: { type: Event.Failed.type, properties: { message } },
-        })
-        return
-      }
-
-      const booted = yield* store.load({ directory: info.directory }).pipe(
-        Effect.as(true),
-        Effect.catch((error) =>
-          Effect.sync(() => {
-            const message = errorMessage(error)
-            log.error("worktree bootstrap failed", { directory: info.directory, message })
-            GlobalBus.emit("event", {
-              directory: info.directory,
-              project: ctx.project.id,
-              workspace: workspaceID,
-              payload: { type: Event.Failed.type, properties: { message } },
-            })
-            return false
-          }),
-        ),
-      )
-      if (!booted) return
-
-      GlobalBus.emit("event", {
-        directory: info.directory,
-        project: ctx.project.id,
-        workspace: workspaceID,
-        payload: {
-          type: Event.Ready.type,
-          properties: { name: info.name, ...(info.branch ? { branch: info.branch } : {}) },
-        },
-      })
-
-      yield* runStartScripts(info.directory, { projectID, extra })
-    })
-
-    const createFromInfo = Effect.fn("Worktree.createFromInfo")(function* (info: Info, startCommand?: string) {
-      yield* setup(info)
-      yield* boot(info, startCommand).pipe(
-        Effect.catchCause((cause) => Effect.sync(() => log.error("worktree bootstrap failed", { cause }))),
-        Effect.forkIn(scope),
-      )
-    })
-
-    const create = Effect.fn("Worktree.create")(function* (input?: CreateInput) {
-      const info = yield* makeWorktreeInfo({ name: input?.name })
-      yield* createFromInfo(info, input?.startCommand)
-      return info
-    })
-
-    const canonical = Effect.fnUntraced(function* (input: string) {
-      const abs = pathSvc.resolve(input)
-      const real = yield* fs.realPath(abs).pipe(Effect.catch(() => Effect.succeed(abs)))
-      const normalized = pathSvc.normalize(real)
-      return process.platform === "win32" ? normalized.toLowerCase() : normalized
-    })
-
-    function parseWorktreeList(text: string) {
-      return text
-        .split("\n")
-        .map((line) => line.trim())
-        .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 locateWorktree = Effect.fnUntraced(function* (
-      entries: { path?: string; branch?: string }[],
-      directory: string,
-    ) {
-      for (const item of entries) {
-        if (!item.path) continue
-        const key = yield* canonical(item.path)
-        if (key === directory) return item
-      }
-      return undefined
-    })
-
-    const list = Effect.fn("Worktree.list")(function* () {
-      const ctx = yield* InstanceState.context
-      if (ctx.project.vcs !== "git") {
-        return []
-      }
-
-      const result = yield* git(["worktree", "list", "--porcelain"], { cwd: ctx.worktree })
-      if (result.code !== 0) {
-        return yield* new ListFailedError({ message: result.stderr || result.text || "Failed to read git worktrees" })
-      }
-
-      const primary = yield* canonical(ctx.worktree)
-      const primaryName = pathSvc.basename(primary).toLowerCase()
-      return yield* Effect.forEach(parseWorktreeList(result.text), (entry) =>
-        Effect.gen(function* () {
-          if (!entry.path) return undefined
-          const directory = yield* canonical(entry.path)
-          if (directory === primary) return undefined
-          const name = pathSvc.basename(directory).toLowerCase()
-          return {
-            name: name === primaryName ? pathSvc.basename(pathSvc.dirname(directory)) : name,
-            directory,
-            ...(entry.branch ? { branch: entry.branch.replace(/^refs\/heads\//, "") } : {}),
-          }
-        }),
-      ).pipe(Effect.map((items) => items.filter((item) => item !== undefined)))
-    })
-
-    function stopFsmonitor(target: string) {
-      return fs.exists(target).pipe(
-        Effect.orDie,
-        Effect.flatMap((exists) => (exists ? git(["fsmonitor--daemon", "stop"], { cwd: target }) : Effect.void)),
-      )
-    }
-
-    function cleanDirectory(target: string) {
-      return Effect.tryPromise({
-        try: () =>
-          import("fs/promises").then((fsp) =>
-            fsp.rm(target, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }),
-          ),
-        catch: (error) =>
-          new RemoveFailedError({ message: errorMessage(error) || "Failed to remove git worktree directory" }),
-      })
-    }
-
-    const remove = Effect.fn("Worktree.remove")(function* (input: RemoveInput) {
-      const ctx = yield* InstanceState.context
-      if (ctx.project.vcs !== "git") {
-        return yield* new NotGitError({ message: "Worktrees are only supported for git projects" })
-      }
-
-      const directory = yield* canonical(input.directory)
-
-      const list = yield* git(["worktree", "list", "--porcelain"], { cwd: ctx.worktree })
-      if (list.code !== 0) {
-        return yield* new RemoveFailedError({ message: list.stderr || list.text || "Failed to read git worktrees" })
-      }
-
-      const entries = parseWorktreeList(list.text)
-      const entry = yield* locateWorktree(entries, directory)
-
-      if (!entry?.path) {
-        const directoryExists = yield* fs.exists(directory).pipe(Effect.orDie)
-        if (directoryExists) {
-          yield* stopFsmonitor(directory)
-          yield* cleanDirectory(directory)
-        }
-        return true
-      }
-
-      yield* stopFsmonitor(entry.path)
-      const removed = yield* git(["worktree", "remove", "--force", entry.path], { cwd: ctx.worktree })
-      if (removed.code !== 0) {
-        const next = yield* git(["worktree", "list", "--porcelain"], { cwd: ctx.worktree })
-        if (next.code !== 0) {
-          return yield* new RemoveFailedError({
-            message: removed.stderr || removed.text || next.stderr || next.text || "Failed to remove git worktree",
-          })
-        }
-
-        const stale = yield* locateWorktree(parseWorktreeList(next.text), directory)
-        if (stale?.path) {
-          return yield* new RemoveFailedError({
-            message: removed.stderr || removed.text || "Failed to remove git worktree",
-          })
-        }
-      }
-
-      yield* cleanDirectory(entry.path)
-
-      const branch = entry.branch?.replace(/^refs\/heads\//, "")
-      if (branch) {
-        const deleted = yield* git(["branch", "-D", branch], { cwd: ctx.worktree })
-        if (deleted.code !== 0) {
-          return yield* new RemoveFailedError({
-            message: deleted.stderr || deleted.text || "Failed to delete worktree branch",
-          })
-        }
-      }
-
-      return true
-    })
-
-    const gitExpect = Effect.fnUntraced(function* (
-      args: string[],
-      opts: { cwd: string },
-      error: (r: GitResult) => Error,
-    ) {
-      const result = yield* git(args, opts)
-      if (result.code !== 0) return yield* error(result)
-      return result
-    })
-
-    const runStartCommand = Effect.fnUntraced(
-      function* (directory: string, cmd: string) {
-        const [shell, args] = process.platform === "win32" ? ["cmd", ["/c", cmd]] : ["bash", ["-lc", cmd]]
-        const result = yield* appProcess.run(
-          ChildProcess.make(shell, args as string[], { cwd: directory, extendEnv: true, stdin: "ignore" }),
-        )
-        return { code: result.exitCode, stderr: result.stderr.toString("utf8") }
-      },
-      Effect.catch(() => Effect.succeed({ code: 1, stderr: "" })),
-    )
-
-    const runStartScript = Effect.fnUntraced(function* (directory: string, cmd: string, kind: string) {
-      const text = cmd.trim()
-      if (!text) return true
-      const result = yield* runStartCommand(directory, text)
-      if (result.code === 0) return true
-      log.error("worktree start command failed", { kind, directory, message: result.stderr })
-      return false
-    })
-
-    const runStartScripts = Effect.fnUntraced(function* (
-      directory: string,
-      input: { projectID: ProjectID; extra?: string },
-    ) {
-      const row = yield* Effect.sync(() =>
-        Database.use((db) => db.select().from(ProjectTable).where(eq(ProjectTable.id, input.projectID)).get()),
-      )
-      const project = row ? Project.fromRow(row) : undefined
-      const startup = project?.commands?.start?.trim() ?? ""
-      const ok = yield* runStartScript(directory, startup, "project")
-      if (!ok) return false
-      yield* runStartScript(directory, input.extra ?? "", "worktree")
-      return true
-    })
-
-    const prune = Effect.fnUntraced(function* (root: string, entries: string[]) {
-      const base = yield* canonical(root)
-      yield* Effect.forEach(
-        entries,
-        (entry) =>
-          Effect.gen(function* () {
-            const target = yield* canonical(pathSvc.resolve(root, entry))
-            if (target === base) return
-            if (!target.startsWith(`${base}${pathSvc.sep}`)) return
-            yield* fs.remove(target, { recursive: true }).pipe(Effect.ignore)
-          }),
-        { concurrency: "unbounded" },
-      )
-    })
-
-    const sweep = Effect.fnUntraced(function* (root: string) {
-      const first = yield* git(["clean", "-ffdx"], { cwd: root })
-      if (first.code === 0) return first
-
-      const entries = failedRemoves(first.stderr, first.text)
-      if (!entries.length) return first
-
-      yield* prune(root, entries)
-      return yield* git(["clean", "-ffdx"], { cwd: root })
-    })
-
-    const reset = Effect.fn("Worktree.reset")(function* (input: ResetInput) {
-      const ctx = yield* InstanceState.context
-      if (ctx.project.vcs !== "git") {
-        return yield* new NotGitError({ message: "Worktrees are only supported for git projects" })
-      }
-
-      const directory = yield* canonical(input.directory)
-      const primary = yield* canonical(ctx.worktree)
-      if (directory === primary) {
-        return yield* new ResetFailedError({ message: "Cannot reset the primary workspace" })
-      }
-
-      const list = yield* git(["worktree", "list", "--porcelain"], { cwd: ctx.worktree })
-      if (list.code !== 0) {
-        return yield* new ResetFailedError({ message: list.stderr || list.text || "Failed to read git worktrees" })
-      }
-
-      const entry = yield* locateWorktree(parseWorktreeList(list.text), directory)
-      if (!entry?.path) {
-        return yield* new ResetFailedError({ message: "Worktree not found" })
-      }
-
-      const worktreePath = entry.path
-
-      const base = yield* gitSvc.defaultBranch(ctx.worktree)
-      if (!base) {
-        return yield* new ResetFailedError({ message: "Default branch not found" })
-      }
-
-      const sep = base.ref.indexOf("/")
-      if (base.ref !== base.name && sep > 0) {
-        const remote = base.ref.slice(0, sep)
-        const branch = base.ref.slice(sep + 1)
-        yield* gitExpect(
-          ["fetch", remote, branch],
-          { cwd: ctx.worktree },
-          (r) => new ResetFailedError({ message: r.stderr || r.text || `Failed to fetch ${base.ref}` }),
-        )
-      }
-
-      yield* gitExpect(
-        ["reset", "--hard", base.ref],
-        { cwd: worktreePath },
-        (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to reset worktree to target" }),
-      )
-
-      const cleanResult = yield* sweep(worktreePath)
-      if (cleanResult.code !== 0) {
-        return yield* new ResetFailedError({
-          message: cleanResult.stderr || cleanResult.text || "Failed to clean worktree",
-        })
-      }
-
-      yield* gitExpect(
-        ["submodule", "update", "--init", "--recursive", "--force"],
-        { cwd: worktreePath },
-        (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to update submodules" }),
-      )
-
-      yield* gitExpect(
-        ["submodule", "foreach", "--recursive", "git", "reset", "--hard"],
-        { cwd: worktreePath },
-        (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to reset submodules" }),
-      )
-
-      yield* gitExpect(
-        ["submodule", "foreach", "--recursive", "git", "clean", "-fdx"],
-        { cwd: worktreePath },
-        (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to clean submodules" }),
-      )
-
-      const status = yield* git(["-c", "core.fsmonitor=false", "status", "--porcelain=v1"], { cwd: worktreePath })
-      if (status.code !== 0) {
-        return yield* new ResetFailedError({ message: status.stderr || status.text || "Failed to read git status" })
-      }
-
-      if (status.text.trim()) {
-        return yield* new ResetFailedError({ message: `Worktree reset left local changes:\n${status.text.trim()}` })
-      }
-
-      yield* runStartScripts(worktreePath, { projectID: ctx.project.id }).pipe(
-        Effect.catchCause((cause) => Effect.sync(() => log.error("worktree start task failed", { cause }))),
-        Effect.forkIn(scope),
-      )
-
-      return true
-    })
-
-    return Service.of({ makeWorktreeInfo, createFromInfo, create, list, remove, reset })
-  }),
-)
-
-export const appLayer = layer.pipe(
-  Layer.provide(Git.defaultLayer),
-  Layer.provide(AppProcess.defaultLayer),
-  Layer.provide(Project.defaultLayer),
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(NodePath.layer),
-)
-
-export const defaultLayer = appLayer.pipe(Layer.provide(InstanceLayer.layer))
-
-export * as Worktree from "."
+import { Global } from "@opencode-ai/core/global"
+import { InstanceLayer } from "@/project/instance-layer"
+import { InstanceStore } from "@/project/instance-store"
+import { Project } from "@/project/project"
+import { Database } from "@/storage/db"
+import { eq } from "drizzle-orm"
+import { ProjectTable } from "../project/project.sql"
+import type { ProjectID } from "../project/schema"
+import * as Log from "@opencode-ai/core/util/log"
+import { Slug } from "@opencode-ai/core/util/slug"
+import { errorMessage } from "../util/error"
+import { BusEvent } from "@/bus/bus-event"
+import { GlobalBus } from "@/bus/global"
+import { Git } from "@/git"
+import { Effect, Layer, Path, Schema, Scope, Context } from "effect"
+import { ChildProcess } from "effect/unstable/process"
+import { NodePath } from "@effect/platform-node"
+import { AppFileSystem } from "@opencode-ai/core/filesystem"
+import { BootstrapRuntime } from "@/effect/bootstrap-runtime"
+import { AppProcess } from "@opencode-ai/core/process"
+import { InstanceState } from "@/effect/instance-state"
+
+const log = Log.create({ service: "worktree" })
+
+export const Event = {
+  Ready: BusEvent.define(
+    "worktree.ready",
+    Schema.Struct({
+      name: Schema.String,
+      branch: Schema.optional(Schema.String),
+    }),
+  ),
+  Failed: BusEvent.define(
+    "worktree.failed",
+    Schema.Struct({
+      message: Schema.String,
+    }),
+  ),
+}
+
+export const Info = Schema.Struct({
+  name: Schema.String,
+  branch: Schema.optional(Schema.String),
+  directory: Schema.String,
+}).annotate({ identifier: "Worktree" })
+export type Info = Schema.Schema.Type<typeof Info>
+
+export const CreateInput = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  startCommand: Schema.optional(
+    Schema.String.annotate({ description: "Additional startup script to run after the project's start command" }),
+  ),
+}).annotate({ identifier: "WorktreeCreateInput" })
+export type CreateInput = Schema.Schema.Type<typeof CreateInput>
+
+export const RemoveInput = Schema.Struct({
+  directory: Schema.String,
+}).annotate({ identifier: "WorktreeRemoveInput" })
+export type RemoveInput = Schema.Schema.Type<typeof RemoveInput>
+
+export const ResetInput = Schema.Struct({
+  directory: Schema.String,
+}).annotate({ identifier: "WorktreeResetInput" })
+export type ResetInput = Schema.Schema.Type<typeof ResetInput>
+
+export class NotGitError extends Schema.TaggedErrorClass<NotGitError>()("WorktreeNotGitError", {
+  message: Schema.String,
+}) {}
+
+export class NameGenerationFailedError extends Schema.TaggedErrorClass<NameGenerationFailedError>()(
+  "WorktreeNameGenerationFailedError",
+  {
+    message: Schema.String,
+  },
+) {}
+
+export class CreateFailedError extends Schema.TaggedErrorClass<CreateFailedError>()("WorktreeCreateFailedError", {
+  message: Schema.String,
+}) {}
+
+export class StartCommandFailedError extends Schema.TaggedErrorClass<StartCommandFailedError>()(
+  "WorktreeStartCommandFailedError",
+  {
+    message: Schema.String,
+  },
+) {}
+
+export class RemoveFailedError extends Schema.TaggedErrorClass<RemoveFailedError>()("WorktreeRemoveFailedError", {
+  message: Schema.String,
+}) {}
+
+export class ResetFailedError extends Schema.TaggedErrorClass<ResetFailedError>()("WorktreeResetFailedError", {
+  message: Schema.String,
+}) {}
+
+export class ListFailedError extends Schema.TaggedErrorClass<ListFailedError>()("WorktreeListFailedError", {
+  message: Schema.String,
+}) {}
+
+export type Error =
+  | NotGitError
+  | NameGenerationFailedError
+  | CreateFailedError
+  | StartCommandFailedError
+  | RemoveFailedError
+  | ResetFailedError
+  | ListFailedError
+
+function slugify(input: string) {
+  return input
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+/, "")
+    .replace(/-+$/, "")
+}
+
+function failedRemoves(...chunks: string[]) {
+  return chunks.filter(Boolean).flatMap((chunk) =>
+    chunk
+      .split("\n")
+      .map((line) => line.trim())
+      .flatMap((line) => {
+        const match = line.match(/^warning:\s+failed to remove\s+(.+):\s+/i)
+        if (!match) return []
+        const value = match[1]?.trim().replace(/^['"]|['"]$/g, "")
+        if (!value) return []
+        return [value]
+      }),
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Effect service
+// ---------------------------------------------------------------------------
+
+export interface Interface {
+  readonly makeWorktreeInfo: (options?: { name?: string; detached?: boolean }) => Effect.Effect<Info, Error>
+  readonly createFromInfo: (info: Info, startCommand?: string) => Effect.Effect<void, Error>
+  readonly create: (input?: CreateInput) => Effect.Effect<Info, Error>
+  readonly list: () => Effect.Effect<(Omit<Info, "branch"> & { branch?: string })[], Error>
+  readonly remove: (input: RemoveInput) => Effect.Effect<boolean, Error>
+  readonly reset: (input: ResetInput) => Effect.Effect<boolean, Error>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/Worktree") {}
+
+type GitResult = { code: number; text: string; stderr: string }
+
+export const layer: Layer.Layer<
+  Service,
+  never,
+  AppFileSystem.Service | Path.Path | AppProcess.Service | Git.Service | Project.Service | InstanceStore.Service
+> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const scope = yield* Scope.Scope
+    const fs = yield* AppFileSystem.Service
+    const pathSvc = yield* Path.Path
+    const appProcess = yield* AppProcess.Service
+    const gitSvc = yield* Git.Service
+    const project = yield* Project.Service
+    const store = yield* InstanceStore.Service
+
+    const git = Effect.fnUntraced(
+      function* (args: string[], opts?: { cwd?: string }) {
+        const result = yield* appProcess.run(
+          ChildProcess.make("git", args, { cwd: opts?.cwd, extendEnv: true, stdin: "ignore" }),
+        )
+        return {
+          code: result.exitCode,
+          text: result.stdout.toString("utf8"),
+          stderr: result.stderr.toString("utf8"),
+        } satisfies GitResult
+      },
+      Effect.catch((e) =>
+        Effect.succeed({
+          code: 1,
+          text: "",
+          stderr: e instanceof Error ? e.message : String(e),
+        } satisfies GitResult),
+      ),
+    )
+
+    const MAX_NAME_ATTEMPTS = 26
+    const candidate = Effect.fn("Worktree.candidate")(function* (input: {
+      root: string
+      name?: string
+      detached?: boolean
+    }) {
+      const ctx = yield* InstanceState.context
+      for (const attempt of Array.from({ length: MAX_NAME_ATTEMPTS }, (_, i) => i)) {
+        const name = input.name ? (attempt === 0 ? input.name : `${input.name}-${Slug.create()}`) : Slug.create()
+        const branch = input.detached ? undefined : `opencode/${name}`
+        const directory = pathSvc.join(input.root, name)
+
+        if (yield* fs.exists(directory).pipe(Effect.orDie)) continue
+
+        if (branch) {
+          const ref = `refs/heads/${branch}`
+          const branchCheck = yield* git(["show-ref", "--verify", "--quiet", ref], { cwd: ctx.worktree })
+          if (branchCheck.code === 0) continue
+        }
+
+        return { name, directory, ...(branch ? { branch } : {}) }
+      }
+      return yield* new NameGenerationFailedError({ message: "Failed to generate a unique worktree name" })
+    })
+
+    const makeWorktreeInfo = Effect.fn("Worktree.makeWorktreeInfo")(function* (input?: {
+      name?: string
+      detached?: boolean
+    }) {
+      const ctx = yield* InstanceState.context
+      if (ctx.project.vcs !== "git") {
+        return yield* new NotGitError({ message: "Worktrees are only supported for git projects" })
+      }
+
+      const root = pathSvc.join(Global.Path.data, "worktree", ctx.project.id)
+      yield* fs.makeDirectory(root, { recursive: true }).pipe(Effect.orDie)
+
+      return yield* candidate({ root, name: input?.name ? slugify(input.name) : "", detached: input?.detached })
+    })
+
+    const setup = Effect.fnUntraced(function* (info: Info) {
+      const ctx = yield* InstanceState.context
+      const created = yield* git(
+        info.branch
+          ? ["worktree", "add", "--no-checkout", "-b", info.branch, info.directory]
+          : ["worktree", "add", "--no-checkout", "--detach", info.directory, "HEAD"],
+        { cwd: ctx.worktree },
+      )
+      if (created.code !== 0) {
+        return yield* new CreateFailedError({
+          message: created.stderr || created.text || "Failed to create git worktree",
+        })
+      }
+
+      yield* project.addSandbox(ctx.project.id, info.directory).pipe(Effect.catch(() => Effect.void))
+    })
+
+    const boot = Effect.fnUntraced(function* (info: Info, startCommand?: string) {
+      const ctx = yield* InstanceState.context
+      const workspaceID = yield* InstanceState.workspaceID
+      const projectID = ctx.project.id
+      const extra = startCommand?.trim()
+
+      const populated = yield* git(["reset", "--hard"], { cwd: info.directory })
+      if (populated.code !== 0) {
+        const message = populated.stderr || populated.text || "Failed to populate worktree"
+        log.error("worktree checkout failed", { directory: info.directory, message })
+        GlobalBus.emit("event", {
+          directory: info.directory,
+          project: ctx.project.id,
+          workspace: workspaceID,
+          payload: { type: Event.Failed.type, properties: { message } },
+        })
+        return
+      }
+
+      const booted = yield* store.load({ directory: info.directory }).pipe(
+        Effect.as(true),
+        Effect.catch((error) =>
+          Effect.sync(() => {
+            const message = errorMessage(error)
+            log.error("worktree bootstrap failed", { directory: info.directory, message })
+            GlobalBus.emit("event", {
+              directory: info.directory,
+              project: ctx.project.id,
+              workspace: workspaceID,
+              payload: { type: Event.Failed.type, properties: { message } },
+            })
+            return false
+          }),
+        ),
+      )
+      if (!booted) return
+
+      GlobalBus.emit("event", {
+        directory: info.directory,
+        project: ctx.project.id,
+        workspace: workspaceID,
+        payload: {
+          type: Event.Ready.type,
+          properties: { name: info.name, ...(info.branch ? { branch: info.branch } : {}) },
+        },
+      })
+
+      yield* runStartScripts(info.directory, { projectID, extra })
+    })
+
+    const createFromInfo = Effect.fn("Worktree.createFromInfo")(function* (info: Info, startCommand?: string) {
+      yield* setup(info)
+      yield* boot(info, startCommand).pipe(
+        Effect.catchCause((cause) => Effect.sync(() => log.error("worktree bootstrap failed", { cause }))),
+        Effect.forkIn(scope),
+      )
+    })
+
+    const create = Effect.fn("Worktree.create")(function* (input?: CreateInput) {
+      const info = yield* makeWorktreeInfo({ name: input?.name })
+      yield* createFromInfo(info, input?.startCommand)
+      return info
+    })
+
+    const canonical = Effect.fnUntraced(function* (input: string) {
+      const abs = pathSvc.resolve(input)
+      const real = yield* fs.realPath(abs).pipe(Effect.catch(() => Effect.succeed(abs)))
+      const normalized = pathSvc.normalize(real)
+      return process.platform === "win32" ? normalized.toLowerCase() : normalized
+    })
+
+    function parseWorktreeList(text: string) {
+      return text
+        .split("\n")
+        .map((line) => line.trim())
+        .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 locateWorktree = Effect.fnUntraced(function* (
+      entries: { path?: string; branch?: string }[],
+      directory: string,
+    ) {
+      for (const item of entries) {
+        if (!item.path) continue
+        const key = yield* canonical(item.path)
+        if (key === directory) return item
+      }
+      return undefined
+    })
+
+    const list = Effect.fn("Worktree.list")(function* () {
+      const ctx = yield* InstanceState.context
+      if (ctx.project.vcs !== "git") {
+        return []
+      }
+
+      const result = yield* git(["worktree", "list", "--porcelain"], { cwd: ctx.worktree })
+      if (result.code !== 0) {
+        return yield* new ListFailedError({ message: result.stderr || result.text || "Failed to read git worktrees" })
+      }
+
+      const primary = yield* canonical(ctx.worktree)
+      const primaryName = pathSvc.basename(primary).toLowerCase()
+      return yield* Effect.forEach(parseWorktreeList(result.text), (entry) =>
+        Effect.gen(function* () {
+          if (!entry.path) return undefined
+          const directory = yield* canonical(entry.path)
+          if (directory === primary) return undefined
+          const name = pathSvc.basename(directory).toLowerCase()
+          return {
+            name: name === primaryName ? pathSvc.basename(pathSvc.dirname(directory)) : name,
+            directory,
+            ...(entry.branch ? { branch: entry.branch.replace(/^refs\/heads\//, "") } : {}),
+          }
+        }),
+      ).pipe(Effect.map((items) => items.filter((item) => item !== undefined)))
+    })
+
+    function stopFsmonitor(target: string) {
+      return fs.exists(target).pipe(
+        Effect.orDie,
+        Effect.flatMap((exists) => (exists ? git(["fsmonitor--daemon", "stop"], { cwd: target }) : Effect.void)),
+      )
+    }
+
+    function cleanDirectory(target: string) {
+      return Effect.tryPromise({
+        try: () =>
+          import("fs/promises").then((fsp) =>
+            fsp.rm(target, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }),
+          ),
+        catch: (error) =>
+          new RemoveFailedError({ message: errorMessage(error) || "Failed to remove git worktree directory" }),
+      })
+    }
+
+    const remove = Effect.fn("Worktree.remove")(function* (input: RemoveInput) {
+      const ctx = yield* InstanceState.context
+      if (ctx.project.vcs !== "git") {
+        return yield* new NotGitError({ message: "Worktrees are only supported for git projects" })
+      }
+
+      const directory = yield* canonical(input.directory)
+
+      const list = yield* git(["worktree", "list", "--porcelain"], { cwd: ctx.worktree })
+      if (list.code !== 0) {
+        return yield* new RemoveFailedError({ message: list.stderr || list.text || "Failed to read git worktrees" })
+      }
+
+      const entries = parseWorktreeList(list.text)
+      const entry = yield* locateWorktree(entries, directory)
+
+      if (!entry?.path) {
+        const directoryExists = yield* fs.exists(directory).pipe(Effect.orDie)
+        if (directoryExists) {
+          yield* stopFsmonitor(directory)
+          yield* cleanDirectory(directory)
+        }
+        return true
+      }
+
+      yield* stopFsmonitor(entry.path)
+      const removed = yield* git(["worktree", "remove", "--force", entry.path], { cwd: ctx.worktree })
+      if (removed.code !== 0) {
+        const next = yield* git(["worktree", "list", "--porcelain"], { cwd: ctx.worktree })
+        if (next.code !== 0) {
+          return yield* new RemoveFailedError({
+            message: removed.stderr || removed.text || next.stderr || next.text || "Failed to remove git worktree",
+          })
+        }
+
+        const stale = yield* locateWorktree(parseWorktreeList(next.text), directory)
+        if (stale?.path) {
+          return yield* new RemoveFailedError({
+            message: removed.stderr || removed.text || "Failed to remove git worktree",
+          })
+        }
+      }
+
+      yield* cleanDirectory(entry.path)
+
+      const branch = entry.branch?.replace(/^refs\/heads\//, "")
+      if (branch) {
+        const deleted = yield* git(["branch", "-D", branch], { cwd: ctx.worktree })
+        if (deleted.code !== 0) {
+          return yield* new RemoveFailedError({
+            message: deleted.stderr || deleted.text || "Failed to delete worktree branch",
+          })
+        }
+      }
+
+      return true
+    })
+
+    const gitExpect = Effect.fnUntraced(function* (
+      args: string[],
+      opts: { cwd: string },
+      error: (r: GitResult) => Error,
+    ) {
+      const result = yield* git(args, opts)
+      if (result.code !== 0) return yield* error(result)
+      return result
+    })
+
+    const runStartCommand = Effect.fnUntraced(
+      function* (directory: string, cmd: string) {
+        const [shell, args] = process.platform === "win32" ? ["cmd", ["/c", cmd]] : ["bash", ["-lc", cmd]]
+        const result = yield* appProcess.run(
+          ChildProcess.make(shell, args as string[], { cwd: directory, extendEnv: true, stdin: "ignore" }),
+        )
+        return { code: result.exitCode, stderr: result.stderr.toString("utf8") }
+      },
+      Effect.catch(() => Effect.succeed({ code: 1, stderr: "" })),
+    )
+
+    const runStartScript = Effect.fnUntraced(function* (directory: string, cmd: string, kind: string) {
+      const text = cmd.trim()
+      if (!text) return true
+      const result = yield* runStartCommand(directory, text)
+      if (result.code === 0) return true
+      log.error("worktree start command failed", { kind, directory, message: result.stderr })
+      return false
+    })
+
+    const runStartScripts = Effect.fnUntraced(function* (
+      directory: string,
+      input: { projectID: ProjectID; extra?: string },
+    ) {
+      const row = yield* Effect.sync(() =>
+        Database.use((db) => db.select().from(ProjectTable).where(eq(ProjectTable.id, input.projectID)).get()),
+      )
+      const project = row ? Project.fromRow(row) : undefined
+      const startup = project?.commands?.start?.trim() ?? ""
+      const ok = yield* runStartScript(directory, startup, "project")
+      if (!ok) return false
+      yield* runStartScript(directory, input.extra ?? "", "worktree")
+      return true
+    })
+
+    const prune = Effect.fnUntraced(function* (root: string, entries: string[]) {
+      const base = yield* canonical(root)
+      yield* Effect.forEach(
+        entries,
+        (entry) =>
+          Effect.gen(function* () {
+            const target = yield* canonical(pathSvc.resolve(root, entry))
+            if (target === base) return
+            if (!target.startsWith(`${base}${pathSvc.sep}`)) return
+            yield* fs.remove(target, { recursive: true }).pipe(Effect.ignore)
+          }),
+        { concurrency: "unbounded" },
+      )
+    })
+
+    const sweep = Effect.fnUntraced(function* (root: string) {
+      const first = yield* git(["clean", "-ffdx"], { cwd: root })
+      if (first.code === 0) return first
+
+      const entries = failedRemoves(first.stderr, first.text)
+      if (!entries.length) return first
+
+      yield* prune(root, entries)
+      return yield* git(["clean", "-ffdx"], { cwd: root })
+    })
+
+    const reset = Effect.fn("Worktree.reset")(function* (input: ResetInput) {
+      const ctx = yield* InstanceState.context
+      if (ctx.project.vcs !== "git") {
+        return yield* new NotGitError({ message: "Worktrees are only supported for git projects" })
+      }
+
+      const directory = yield* canonical(input.directory)
+      const primary = yield* canonical(ctx.worktree)
+      if (directory === primary) {
+        return yield* new ResetFailedError({ message: "Cannot reset the primary workspace" })
+      }
+
+      const list = yield* git(["worktree", "list", "--porcelain"], { cwd: ctx.worktree })
+      if (list.code !== 0) {
+        return yield* new ResetFailedError({ message: list.stderr || list.text || "Failed to read git worktrees" })
+      }
+
+      const entry = yield* locateWorktree(parseWorktreeList(list.text), directory)
+      if (!entry?.path) {
+        return yield* new ResetFailedError({ message: "Worktree not found" })
+      }
+
+      const worktreePath = entry.path
+
+      const base = yield* gitSvc.defaultBranch(ctx.worktree)
+      if (!base) {
+        return yield* new ResetFailedError({ message: "Default branch not found" })
+      }
+
+      const sep = base.ref.indexOf("/")
+      if (base.ref !== base.name && sep > 0) {
+        const remote = base.ref.slice(0, sep)
+        const branch = base.ref.slice(sep + 1)
+        yield* gitExpect(
+          ["fetch", remote, branch],
+          { cwd: ctx.worktree },
+          (r) => new ResetFailedError({ message: r.stderr || r.text || `Failed to fetch ${base.ref}` }),
+        )
+      }
+
+      yield* gitExpect(
+        ["reset", "--hard", base.ref],
+        { cwd: worktreePath },
+        (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to reset worktree to target" }),
+      )
+
+      const cleanResult = yield* sweep(worktreePath)
+      if (cleanResult.code !== 0) {
+        return yield* new ResetFailedError({
+          message: cleanResult.stderr || cleanResult.text || "Failed to clean worktree",
+        })
+      }
+
+      yield* gitExpect(
+        ["submodule", "update", "--init", "--recursive", "--force"],
+        { cwd: worktreePath },
+        (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to update submodules" }),
+      )
+
+      yield* gitExpect(
+        ["submodule", "foreach", "--recursive", "git", "reset", "--hard"],
+        { cwd: worktreePath },
+        (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to reset submodules" }),
+      )
+
+      yield* gitExpect(
+        ["submodule", "foreach", "--recursive", "git", "clean", "-fdx"],
+        { cwd: worktreePath },
+        (r) => new ResetFailedError({ message: r.stderr || r.text || "Failed to clean submodules" }),
+      )
+
+      const status = yield* git(["-c", "core.fsmonitor=false", "status", "--porcelain=v1"], { cwd: worktreePath })
+      if (status.code !== 0) {
+        return yield* new ResetFailedError({ message: status.stderr || status.text || "Failed to read git status" })
+      }
+
+      if (status.text.trim()) {
+        return yield* new ResetFailedError({ message: `Worktree reset left local changes:\n${status.text.trim()}` })
+      }
+
+      yield* runStartScripts(worktreePath, { projectID: ctx.project.id }).pipe(
+        Effect.catchCause((cause) => Effect.sync(() => log.error("worktree start task failed", { cause }))),
+        Effect.forkIn(scope),
+      )
+
+      return true
+    })
+
+    return Service.of({ makeWorktreeInfo, createFromInfo, create, list, remove, reset })
+  }),
+)
+
+export const appLayer = layer.pipe(
+  Layer.provide(Git.defaultLayer),
+  Layer.provide(AppProcess.defaultLayer),
+  Layer.provide(Project.defaultLayer),
+  Layer.provide(AppFileSystem.defaultLayer),
+  Layer.provide(NodePath.layer),
+)
+
+export const defaultLayer = appLayer.pipe(Layer.provide(InstanceLayer.layer))
+
+export * as Worktree from "."