chore: initialize qiming workspace repository

qimingcode/packages/opencode/test/project/migrate-global.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, test } from "bun:test"
+import { Project } from "../../src/project"
+import { Database, eq } from "../../src/storage"
+import { SessionTable } from "../../src/session/session.sql"
+import { ProjectTable } from "../../src/project/project.sql"
+import { ProjectID } from "../../src/project/schema"
+import { SessionID } from "../../src/session/schema"
+import { Log } from "../../src/util"
+import { $ } from "bun"
+import { tmpdir } from "../fixture/fixture"
+import { Effect } from "effect"
+
+Log.init({ print: false })
+
+function run<A>(fn: (svc: Project.Interface) => Effect.Effect<A>) {
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const svc = yield* Project.Service
+      return yield* fn(svc)
+    }).pipe(Effect.provide(Project.defaultLayer)),
+  )
+}
+
+function uid() {
+  return SessionID.make(crypto.randomUUID())
+}
+
+function seed(opts: { id: SessionID; dir: string; project: ProjectID }) {
+  const now = Date.now()
+  Database.use((db) =>
+    db
+      .insert(SessionTable)
+      .values({
+        id: opts.id,
+        project_id: opts.project,
+        slug: opts.id,
+        directory: opts.dir,
+        title: "test",
+        version: "0.0.0-test",
+        time_created: now,
+        time_updated: now,
+      })
+      .run(),
+  )
+}
+
+function ensureGlobal() {
+  Database.use((db) =>
+    db
+      .insert(ProjectTable)
+      .values({
+        id: ProjectID.global,
+        worktree: "/",
+        time_created: Date.now(),
+        time_updated: Date.now(),
+        sandboxes: [],
+      })
+      .onConflictDoNothing()
+      .run(),
+  )
+}
+
+describe("migrateFromGlobal", () => {
+  test("migrates global sessions on first project creation", async () => {
+    // 1. Start with git init but no commits — creates "global" project row
+    await using tmp = await tmpdir()
+    await $`git init`.cwd(tmp.path).quiet()
+    await $`git config user.name "Test"`.cwd(tmp.path).quiet()
+    await $`git config user.email "test@opencode.test"`.cwd(tmp.path).quiet()
+    await $`git config commit.gpgsign false`.cwd(tmp.path).quiet()
+    const { project: pre } = await run((svc) => svc.fromDirectory(tmp.path))
+    expect(pre.id).toBe(ProjectID.global)
+
+    // 2. Seed a session under "global" with matching directory
+    const id = uid()
+    seed({ id, dir: tmp.path, project: ProjectID.global })
+
+    // 3. Make a commit so the project gets a real ID
+    await $`git commit --allow-empty -m "root"`.cwd(tmp.path).quiet()
+
+    const { project: real } = await run((svc) => svc.fromDirectory(tmp.path))
+    expect(real.id).not.toBe(ProjectID.global)
+
+    // 4. The session should have been migrated to the real project ID
+    const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
+    expect(row).toBeDefined()
+    expect(row!.project_id).toBe(real.id)
+  })
+
+  test("migrates global sessions even when project row already exists", async () => {
+    // 1. Create a repo with a commit — real project ID created immediately
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+    expect(project.id).not.toBe(ProjectID.global)
+
+    // 2. Ensure "global" project row exists (as it would from a prior no-git session)
+    ensureGlobal()
+
+    // 3. Seed a session under "global" with matching directory.
+    //    This simulates a session created before git init that wasn't
+    //    present when the real project row was first created.
+    const id = uid()
+    seed({ id, dir: tmp.path, project: ProjectID.global })
+
+    // 4. Call fromDirectory again — project row already exists,
+    //    so the current code skips migration entirely. This is the bug.
+    await run((svc) => svc.fromDirectory(tmp.path))
+
+    const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
+    expect(row).toBeDefined()
+    expect(row!.project_id).toBe(project.id)
+  })
+
+  test("does not claim sessions with empty directory", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+    expect(project.id).not.toBe(ProjectID.global)
+
+    ensureGlobal()
+
+    // Legacy sessions may lack a directory value.
+    // Without a matching origin directory, they should remain global.
+    const id = uid()
+    seed({ id, dir: "", project: ProjectID.global })
+
+    await run((svc) => svc.fromDirectory(tmp.path))
+
+    const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
+    expect(row).toBeDefined()
+    expect(row!.project_id).toBe(ProjectID.global)
+  })
+
+  test("does not steal sessions from unrelated directories", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+    expect(project.id).not.toBe(ProjectID.global)
+
+    ensureGlobal()
+
+    // Seed a session under "global" but for a DIFFERENT directory
+    const id = uid()
+    seed({ id, dir: "/some/other/dir", project: ProjectID.global })
+
+    await run((svc) => svc.fromDirectory(tmp.path))
+
+    const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
+    expect(row).toBeDefined()
+    // Should remain under "global" — not stolen
+    expect(row!.project_id).toBe(ProjectID.global)
+  })
+})

qimingcode/packages/opencode/test/project/project.test.ts

@@ -0,0 +1,601 @@
+import { describe, expect, test } from "bun:test"
+import { Project } from "../../src/project"
+import { Log } from "../../src/util"
+import { $ } from "bun"
+import path from "path"
+import { tmpdir } from "../fixture/fixture"
+import { GlobalBus } from "../../src/bus/global"
+import { ProjectID } from "../../src/project/schema"
+import { Effect, Layer, Stream } from "effect"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import { NodePath } from "@effect/platform-node"
+import { AppFileSystem } from "@opencode-ai/core/filesystem"
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+
+void Log.init({ print: false })
+
+const encoder = new TextEncoder()
+
+function run<A>(fn: (svc: Project.Interface) => Effect.Effect<A>, layer = Project.defaultLayer) {
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const svc = yield* Project.Service
+      return yield* fn(svc)
+    }).pipe(Effect.provide(layer)),
+  )
+}
+
+/**
+ * Creates a mock ChildProcessSpawner layer that intercepts git subcommands
+ * matching `failArg` and returns exit code 128, while delegating everything
+ * else to the real CrossSpawnSpawner.
+ */
+function mockGitFailure(failArg: string) {
+  return Layer.effect(
+    ChildProcessSpawner.ChildProcessSpawner,
+    Effect.gen(function* () {
+      const real = yield* ChildProcessSpawner.ChildProcessSpawner
+      return ChildProcessSpawner.make(
+        Effect.fnUntraced(function* (command) {
+          const std = ChildProcess.isStandardCommand(command) ? command : undefined
+          if (std?.command === "git" && std.args.some((a) => a === failArg)) {
+            return ChildProcessSpawner.makeHandle({
+              pid: ChildProcessSpawner.ProcessId(0),
+              exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(128)),
+              isRunning: Effect.succeed(false),
+              kill: () => Effect.void,
+              stdin: { [Symbol.for("effect/Sink/TypeId")]: Symbol.for("effect/Sink/TypeId") } as any,
+              stdout: Stream.empty,
+              stderr: Stream.make(encoder.encode("fatal: simulated failure\n")),
+              all: Stream.empty,
+              getInputFd: () => ({ [Symbol.for("effect/Sink/TypeId")]: Symbol.for("effect/Sink/TypeId") }) as any,
+              getOutputFd: () => Stream.empty,
+              unref: Effect.succeed(Effect.void),
+            })
+          }
+          return yield* real.spawn(command)
+        }),
+      )
+    }),
+  ).pipe(Layer.provide(CrossSpawnSpawner.defaultLayer))
+}
+
+function projectLayerWithFailure(failArg: string) {
+  return Project.layer.pipe(
+    Layer.provide(mockGitFailure(failArg)),
+    Layer.provide(AppFileSystem.defaultLayer),
+    Layer.provide(NodePath.layer),
+  )
+}
+
+describe("Project.fromDirectory", () => {
+  test("should handle git repository with no commits", async () => {
+    await using tmp = await tmpdir()
+    await $`git init`.cwd(tmp.path).quiet()
+
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    expect(project).toBeDefined()
+    expect(project.id).toBe(ProjectID.global)
+    expect(project.vcs).toBe("git")
+    expect(project.worktree).toBe(tmp.path)
+
+    const opencodeFile = path.join(tmp.path, ".git", "opencode")
+    expect(await Bun.file(opencodeFile).exists()).toBe(false)
+  })
+
+  test("should handle git repository with commits", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    expect(project).toBeDefined()
+    expect(project.id).not.toBe(ProjectID.global)
+    expect(project.vcs).toBe("git")
+    expect(project.worktree).toBe(tmp.path)
+
+    const opencodeFile = path.join(tmp.path, ".git", "opencode")
+    expect(await Bun.file(opencodeFile).exists()).toBe(true)
+  })
+
+  test("returns global for non-git directory", async () => {
+    await using tmp = await tmpdir()
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+    expect(project.id).toBe(ProjectID.global)
+  })
+
+  test("derives stable project ID from root commit", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project: a } = await run((svc) => svc.fromDirectory(tmp.path))
+    const { project: b } = await run((svc) => svc.fromDirectory(tmp.path))
+    expect(b.id).toBe(a.id)
+  })
+})
+
+describe("Project.fromDirectory git failure paths", () => {
+  test("keeps vcs when rev-list exits non-zero (no commits)", async () => {
+    await using tmp = await tmpdir()
+    await $`git init`.cwd(tmp.path).quiet()
+
+    // rev-list fails because HEAD doesn't exist yet — this is the natural scenario
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+    expect(project.vcs).toBe("git")
+    expect(project.id).toBe(ProjectID.global)
+    expect(project.worktree).toBe(tmp.path)
+  })
+
+  test("handles show-toplevel failure gracefully", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const layer = projectLayerWithFailure("--show-toplevel")
+
+    const { project, sandbox } = await run((svc) => svc.fromDirectory(tmp.path), layer)
+    expect(project.worktree).toBe(tmp.path)
+    expect(sandbox).toBe(tmp.path)
+  })
+
+  test("handles git-common-dir failure gracefully", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const layer = projectLayerWithFailure("--git-common-dir")
+
+    const { project, sandbox } = await run((svc) => svc.fromDirectory(tmp.path), layer)
+    expect(project.worktree).toBe(tmp.path)
+    expect(sandbox).toBe(tmp.path)
+  })
+})
+
+describe("Project.fromDirectory with worktrees", () => {
+  test("should set worktree to root when called from root", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const { project, sandbox } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    expect(project.worktree).toBe(tmp.path)
+    expect(sandbox).toBe(tmp.path)
+    expect(project.sandboxes).not.toContain(tmp.path)
+  })
+
+  test("should set worktree to root when called from a worktree", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const worktreePath = path.join(tmp.path, "..", path.basename(tmp.path) + "-worktree")
+    try {
+      await $`git worktree add ${worktreePath} -b test-branch-${Date.now()}`.cwd(tmp.path).quiet()
+
+      const { project, sandbox } = await run((svc) => svc.fromDirectory(worktreePath))
+
+      expect(project.worktree).toBe(tmp.path)
+      expect(sandbox).toBe(worktreePath)
+      expect(project.sandboxes).toContain(worktreePath)
+      expect(project.sandboxes).not.toContain(tmp.path)
+    } finally {
+      await $`git worktree remove ${worktreePath}`
+        .cwd(tmp.path)
+        .quiet()
+        .catch(() => {})
+    }
+  })
+
+  test("worktree should share project ID with main repo", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const { project: main } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const worktreePath = path.join(tmp.path, "..", path.basename(tmp.path) + "-wt-shared")
+    try {
+      await $`git worktree add ${worktreePath} -b shared-${Date.now()}`.cwd(tmp.path).quiet()
+
+      const { project: wt } = await run((svc) => svc.fromDirectory(worktreePath))
+
+      expect(wt.id).toBe(main.id)
+
+      // Cache should live in the common .git dir, not the worktree's .git file
+      const cache = path.join(tmp.path, ".git", "opencode")
+      const exists = await Bun.file(cache).exists()
+      expect(exists).toBe(true)
+    } finally {
+      await $`git worktree remove ${worktreePath}`
+        .cwd(tmp.path)
+        .quiet()
+        .catch(() => {})
+    }
+  })
+
+  test("separate clones of the same repo should share project ID", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    // Create a bare remote, push, then clone into a second directory
+    const bare = tmp.path + "-bare"
+    const clone = tmp.path + "-clone"
+    try {
+      await $`git clone --bare ${tmp.path} ${bare}`.quiet()
+      await $`git clone ${bare} ${clone}`.quiet()
+
+      const { project: a } = await run((svc) => svc.fromDirectory(tmp.path))
+      const { project: b } = await run((svc) => svc.fromDirectory(clone))
+
+      expect(b.id).toBe(a.id)
+    } finally {
+      await $`rm -rf ${bare} ${clone}`.quiet().nothrow()
+    }
+  })
+
+  test("should accumulate multiple worktrees in sandboxes", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const worktree1 = path.join(tmp.path, "..", path.basename(tmp.path) + "-wt1")
+    const worktree2 = path.join(tmp.path, "..", path.basename(tmp.path) + "-wt2")
+    try {
+      await $`git worktree add ${worktree1} -b branch-${Date.now()}`.cwd(tmp.path).quiet()
+      await $`git worktree add ${worktree2} -b branch-${Date.now() + 1}`.cwd(tmp.path).quiet()
+
+      await run((svc) => svc.fromDirectory(worktree1))
+      const { project } = await run((svc) => svc.fromDirectory(worktree2))
+
+      expect(project.worktree).toBe(tmp.path)
+      expect(project.sandboxes).toContain(worktree1)
+      expect(project.sandboxes).toContain(worktree2)
+      expect(project.sandboxes).not.toContain(tmp.path)
+    } finally {
+      await $`git worktree remove ${worktree1}`
+        .cwd(tmp.path)
+        .quiet()
+        .catch(() => {})
+      await $`git worktree remove ${worktree2}`
+        .cwd(tmp.path)
+        .quiet()
+        .catch(() => {})
+    }
+  })
+})
+
+describe("Project.discover", () => {
+  test("should discover favicon.png in root", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const pngData = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
+    await Bun.write(path.join(tmp.path, "favicon.png"), pngData)
+
+    await run((svc) => svc.discover(project))
+
+    const updated = Project.get(project.id)
+    expect(updated).toBeDefined()
+    expect(updated!.icon).toBeDefined()
+    expect(updated!.icon?.url).toStartWith("data:")
+    expect(updated!.icon?.url).toContain("base64")
+    expect(updated!.icon?.color).toBeUndefined()
+  })
+
+  test("should not discover non-image files", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    await Bun.write(path.join(tmp.path, "favicon.txt"), "not an image")
+
+    await run((svc) => svc.discover(project))
+
+    const updated = Project.get(project.id)
+    expect(updated).toBeDefined()
+    expect(updated!.icon).toBeUndefined()
+  })
+
+  test("should not discover favicon when override is set", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        icon: { override: "data:image/png;base64,override" },
+      }),
+    )
+
+    const updatedProject = await run((svc) => svc.get(project.id))
+    if (!updatedProject) throw new Error("Project not found")
+
+    const pngData = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
+    await Bun.write(path.join(tmp.path, "favicon.png"), pngData)
+
+    await run((svc) => svc.discover(updatedProject))
+
+    const updated = Project.get(project.id)
+    expect(updated).toBeDefined()
+    expect(updated!.icon?.override).toBe("data:image/png;base64,override")
+    expect(updated!.icon?.url).toBeUndefined()
+  })
+})
+
+describe("Project.update", () => {
+  test("should update name", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const updated = await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        name: "New Project Name",
+      }),
+    )
+
+    expect(updated.name).toBe("New Project Name")
+
+    const fromDb = Project.get(project.id)
+    expect(fromDb?.name).toBe("New Project Name")
+  })
+
+  test("should update icon url", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const updated = await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        icon: { url: "https://example.com/icon.png" },
+      }),
+    )
+
+    expect(updated.icon?.url).toBe("https://example.com/icon.png")
+
+    const fromDb = Project.get(project.id)
+    expect(fromDb?.icon?.url).toBe("https://example.com/icon.png")
+  })
+
+  test("should update icon color", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const updated = await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        icon: { color: "#ff0000" },
+      }),
+    )
+
+    expect(updated.icon?.color).toBe("#ff0000")
+
+    const fromDb = Project.get(project.id)
+    expect(fromDb?.icon?.color).toBe("#ff0000")
+  })
+
+  test("should update icon override", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const updated = await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        icon: { override: "data:image/png;base64,abc123" },
+      }),
+    )
+
+    expect(updated.icon?.override).toBe("data:image/png;base64,abc123")
+
+    const fromDb = Project.get(project.id)
+    expect(fromDb?.icon?.override).toBe("data:image/png;base64,abc123")
+  })
+
+  test("should update commands", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const updated = await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        commands: { start: "npm run dev" },
+      }),
+    )
+
+    expect(updated.commands?.start).toBe("npm run dev")
+
+    const fromDb = Project.get(project.id)
+    expect(fromDb?.commands?.start).toBe("npm run dev")
+  })
+
+  test("should throw error when project not found", async () => {
+    await expect(
+      run((svc) =>
+        svc.update({
+          projectID: ProjectID.make("nonexistent-project-id"),
+          name: "Should Fail",
+        }),
+      ),
+    ).rejects.toThrow("Project not found: nonexistent-project-id")
+  })
+
+  test("should emit GlobalBus event on update", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    let eventPayload: any = null
+    const on = (data: any) => {
+      eventPayload = data
+    }
+    GlobalBus.on("event", on)
+
+    try {
+      await run((svc) => svc.update({ projectID: project.id, name: "Updated Name" }))
+
+      expect(eventPayload).not.toBeNull()
+      expect(eventPayload.payload.type).toBe("project.updated")
+      expect(eventPayload.payload.properties.name).toBe("Updated Name")
+    } finally {
+      GlobalBus.off("event", on)
+    }
+  })
+
+  test("should update multiple fields at once", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const updated = await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        name: "Multi Update",
+        icon: { url: "https://example.com/favicon.ico", override: "data:image/png;base64,abc123", color: "#00ff00" },
+        commands: { start: "make start" },
+      }),
+    )
+
+    expect(updated.name).toBe("Multi Update")
+    expect(updated.icon?.url).toBe("https://example.com/favicon.ico")
+    expect(updated.icon?.override).toBe("data:image/png;base64,abc123")
+    expect(updated.icon?.color).toBe("#00ff00")
+    expect(updated.commands?.start).toBe("make start")
+  })
+})
+
+describe("Project.list and Project.get", () => {
+  test("list returns all projects", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const all = Project.list()
+    expect(all.length).toBeGreaterThan(0)
+    expect(all.find((p) => p.id === project.id)).toBeDefined()
+  })
+
+  test("get returns project by id", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const found = Project.get(project.id)
+    expect(found).toBeDefined()
+    expect(found!.id).toBe(project.id)
+  })
+
+  test("get returns undefined for unknown id", () => {
+    const found = Project.get(ProjectID.make("nonexistent"))
+    expect(found).toBeUndefined()
+  })
+})
+
+describe("Project.setInitialized", () => {
+  test("sets time_initialized on project", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    expect(project.time.initialized).toBeUndefined()
+
+    Project.setInitialized(project.id)
+
+    const updated = Project.get(project.id)
+    expect(updated?.time.initialized).toBeDefined()
+  })
+})
+
+describe("Project.addSandbox and Project.removeSandbox", () => {
+  test("addSandbox adds directory and removeSandbox removes it", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+    const sandboxDir = path.join(tmp.path, "sandbox-test")
+
+    await run((svc) => svc.addSandbox(project.id, sandboxDir))
+
+    let found = Project.get(project.id)
+    expect(found?.sandboxes).toContain(sandboxDir)
+
+    await run((svc) => svc.removeSandbox(project.id, sandboxDir))
+
+    found = Project.get(project.id)
+    expect(found?.sandboxes).not.toContain(sandboxDir)
+  })
+
+  test("addSandbox emits GlobalBus event", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+    const sandboxDir = path.join(tmp.path, "sandbox-event")
+
+    const events: any[] = []
+    const on = (evt: any) => events.push(evt)
+    GlobalBus.on("event", on)
+
+    await run((svc) => svc.addSandbox(project.id, sandboxDir))
+
+    GlobalBus.off("event", on)
+    expect(events.some((e) => e.payload.type === Project.Event.Updated.type)).toBe(true)
+  })
+})
+
+describe("Project.fromDirectory with bare repos", () => {
+  test("worktree from bare repo should cache in bare repo, not parent", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const parentDir = path.dirname(tmp.path)
+    const barePath = path.join(parentDir, `bare-${Date.now()}.git`)
+    const worktreePath = path.join(parentDir, `worktree-${Date.now()}`)
+
+    try {
+      await $`git clone --bare ${tmp.path} ${barePath}`.quiet()
+      await $`git worktree add ${worktreePath} HEAD`.cwd(barePath).quiet()
+
+      const { project } = await run((svc) => svc.fromDirectory(worktreePath))
+
+      expect(project.id).not.toBe(ProjectID.global)
+      expect(project.worktree).toBe(barePath)
+
+      const correctCache = path.join(barePath, "opencode")
+      const wrongCache = path.join(parentDir, ".git", "opencode")
+
+      expect(await Bun.file(correctCache).exists()).toBe(true)
+      expect(await Bun.file(wrongCache).exists()).toBe(false)
+    } finally {
+      await $`rm -rf ${barePath} ${worktreePath}`.quiet().nothrow()
+    }
+  })
+
+  test("different bare repos under same parent should not share project ID", async () => {
+    await using tmp1 = await tmpdir({ git: true })
+    await using tmp2 = await tmpdir({ git: true })
+
+    const parentDir = path.dirname(tmp1.path)
+    const bareA = path.join(parentDir, `bare-a-${Date.now()}.git`)
+    const bareB = path.join(parentDir, `bare-b-${Date.now()}.git`)
+    const worktreeA = path.join(parentDir, `wt-a-${Date.now()}`)
+    const worktreeB = path.join(parentDir, `wt-b-${Date.now()}`)
+
+    try {
+      await $`git clone --bare ${tmp1.path} ${bareA}`.quiet()
+      await $`git clone --bare ${tmp2.path} ${bareB}`.quiet()
+      await $`git worktree add ${worktreeA} HEAD`.cwd(bareA).quiet()
+      await $`git worktree add ${worktreeB} HEAD`.cwd(bareB).quiet()
+
+      const { project: projA } = await run((svc) => svc.fromDirectory(worktreeA))
+      const { project: projB } = await run((svc) => svc.fromDirectory(worktreeB))
+
+      expect(projA.id).not.toBe(projB.id)
+
+      const cacheA = path.join(bareA, "opencode")
+      const cacheB = path.join(bareB, "opencode")
+      const wrongCache = path.join(parentDir, ".git", "opencode")
+
+      expect(await Bun.file(cacheA).exists()).toBe(true)
+      expect(await Bun.file(cacheB).exists()).toBe(true)
+      expect(await Bun.file(wrongCache).exists()).toBe(false)
+    } finally {
+      await $`rm -rf ${bareA} ${bareB} ${worktreeA} ${worktreeB}`.quiet().nothrow()
+    }
+  })
+
+  test("bare repo without .git suffix is still detected via core.bare", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const parentDir = path.dirname(tmp.path)
+    const barePath = path.join(parentDir, `bare-no-suffix-${Date.now()}`)
+    const worktreePath = path.join(parentDir, `worktree-${Date.now()}`)
+
+    try {
+      await $`git clone --bare ${tmp.path} ${barePath}`.quiet()
+      await $`git worktree add ${worktreePath} HEAD`.cwd(barePath).quiet()
+
+      const { project } = await run((svc) => svc.fromDirectory(worktreePath))
+
+      expect(project.id).not.toBe(ProjectID.global)
+      expect(project.worktree).toBe(barePath)
+
+      const correctCache = path.join(barePath, "opencode")
+      expect(await Bun.file(correctCache).exists()).toBe(true)
+    } finally {
+      await $`rm -rf ${barePath} ${worktreePath}`.quiet().nothrow()
+    }
+  })
+})

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

@@ -0,0 +1,286 @@
+import { $ } from "bun"
+import { afterEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import fs from "fs/promises"
+import path from "path"
+import { tmpdir } from "../fixture/fixture"
+import { AppRuntime } from "../../src/effect/app-runtime"
+import { FileWatcher } from "../../src/file/watcher"
+import { Instance } from "../../src/project/instance"
+import { GlobalBus } from "../../src/bus/global"
+import { Vcs } from "../../src/project"
+
+// Skip in CI — native @parcel/watcher binding needed
+const describeVcs = FileWatcher.hasNativeBinding() && !process.env.CI ? describe : describe.skip
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+async function withVcs(directory: string, body: () => Promise<void>) {
+  return Instance.provide({
+    directory,
+    fn: async () => {
+      await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const watcher = yield* FileWatcher.Service
+          const vcs = yield* Vcs.Service
+          yield* watcher.init()
+          yield* vcs.init()
+        }),
+      )
+      await Bun.sleep(500)
+      await body()
+    },
+  })
+}
+
+function withVcsOnly(directory: string, body: () => Promise<void>) {
+  return Instance.provide({
+    directory,
+    fn: async () => {
+      await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          yield* vcs.init()
+        }),
+      )
+      await body()
+    },
+  })
+}
+
+type BranchEvent = { directory?: string; payload: { type: string; properties: { branch?: string } } }
+const weird = process.platform === "win32" ? "space file.txt" : "tab\tfile.txt"
+
+/** Wait for a Vcs.Event.BranchUpdated event on GlobalBus, with retry polling as fallback */
+function nextBranchUpdate(directory: string, timeout = 10_000) {
+  return new Promise<string | undefined>((resolve, reject) => {
+    let settled = false
+
+    const timer = setTimeout(() => {
+      if (settled) return
+      settled = true
+      GlobalBus.off("event", on)
+      reject(new Error("timed out waiting for BranchUpdated event"))
+    }, timeout)
+
+    function on(evt: BranchEvent) {
+      if (evt.directory !== directory) return
+      if (evt.payload.type !== Vcs.Event.BranchUpdated.type) return
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      GlobalBus.off("event", on)
+      resolve(evt.payload.properties.branch)
+    }
+
+    GlobalBus.on("event", on)
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describeVcs("Vcs", () => {
+  afterEach(async () => {
+    await Instance.disposeAll()
+  })
+
+  test("branch() returns current branch name", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    await withVcs(tmp.path, async () => {
+      const branch = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.branch()
+        }),
+      )
+      expect(branch).toBeDefined()
+      expect(typeof branch).toBe("string")
+    })
+  })
+
+  test("branch() returns undefined for non-git directories", async () => {
+    await using tmp = await tmpdir()
+
+    await withVcs(tmp.path, async () => {
+      const branch = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.branch()
+        }),
+      )
+      expect(branch).toBeUndefined()
+    })
+  })
+
+  test("publishes BranchUpdated when .git/HEAD changes", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const branch = `test-${Math.random().toString(36).slice(2)}`
+    await $`git branch ${branch}`.cwd(tmp.path).quiet()
+
+    await withVcs(tmp.path, async () => {
+      const pending = nextBranchUpdate(tmp.path)
+
+      const head = path.join(tmp.path, ".git", "HEAD")
+      await fs.writeFile(head, `ref: refs/heads/${branch}\n`)
+
+      const updated = await pending
+      expect(updated).toBe(branch)
+    })
+  })
+
+  test("branch() reflects the new branch after HEAD change", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const branch = `test-${Math.random().toString(36).slice(2)}`
+    await $`git branch ${branch}`.cwd(tmp.path).quiet()
+
+    await withVcs(tmp.path, async () => {
+      const pending = nextBranchUpdate(tmp.path)
+
+      const head = path.join(tmp.path, ".git", "HEAD")
+      await fs.writeFile(head, `ref: refs/heads/${branch}\n`)
+
+      await pending
+      const current = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.branch()
+        }),
+      )
+      expect(current).toBe(branch)
+    })
+  })
+})
+
+describe("Vcs diff", () => {
+  afterEach(async () => {
+    await Instance.disposeAll()
+  })
+
+  test("defaultBranch() falls back to main", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await $`git branch -M main`.cwd(tmp.path).quiet()
+
+    await withVcsOnly(tmp.path, async () => {
+      const branch = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.defaultBranch()
+        }),
+      )
+      expect(branch).toBe("main")
+    })
+  })
+
+  test("defaultBranch() uses init.defaultBranch when available", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await $`git branch -M trunk`.cwd(tmp.path).quiet()
+    await $`git config init.defaultBranch trunk`.cwd(tmp.path).quiet()
+
+    await withVcsOnly(tmp.path, async () => {
+      const branch = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.defaultBranch()
+        }),
+      )
+      expect(branch).toBe("trunk")
+    })
+  })
+
+  test("detects current branch from the active worktree", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await using wt = await tmpdir()
+    await $`git branch -M main`.cwd(tmp.path).quiet()
+    const dir = path.join(wt.path, "feature")
+    await $`git worktree add -b feature/test ${dir} HEAD`.cwd(tmp.path).quiet()
+
+    await withVcsOnly(dir, async () => {
+      const [branch, base] = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* Effect.all([vcs.branch(), vcs.defaultBranch()], { concurrency: 2 })
+        }),
+      )
+      expect(branch).toBe("feature/test")
+      expect(base).toBe("main")
+    })
+  })
+
+  test("diff('git') returns uncommitted changes", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await fs.writeFile(path.join(tmp.path, "file.txt"), "original\n", "utf-8")
+    await $`git add .`.cwd(tmp.path).quiet()
+    await $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet()
+    await fs.writeFile(path.join(tmp.path, "file.txt"), "changed\n", "utf-8")
+
+    await withVcsOnly(tmp.path, async () => {
+      const diff = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.diff("git")
+        }),
+      )
+      expect(diff).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            file: "file.txt",
+            status: "modified",
+          }),
+        ]),
+      )
+    })
+  })
+
+  test("diff('git') handles special filenames", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await fs.writeFile(path.join(tmp.path, weird), "hello\n", "utf-8")
+
+    await withVcsOnly(tmp.path, async () => {
+      const diff = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.diff("git")
+        }),
+      )
+      expect(diff).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            file: weird,
+            status: "added",
+          }),
+        ]),
+      )
+    })
+  })
+
+  test("diff('branch') returns changes against default branch", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await $`git branch -M main`.cwd(tmp.path).quiet()
+    await $`git checkout -b feature/test`.cwd(tmp.path).quiet()
+    await fs.writeFile(path.join(tmp.path, "branch.txt"), "hello\n", "utf-8")
+    await $`git add .`.cwd(tmp.path).quiet()
+    await $`git commit --no-gpg-sign -m "branch file"`.cwd(tmp.path).quiet()
+
+    await withVcsOnly(tmp.path, async () => {
+      const diff = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.diff("branch")
+        }),
+      )
+      expect(diff).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            file: "branch.txt",
+            status: "added",
+          }),
+        ]),
+      )
+    })
+  })
+})

qimingcode/packages/opencode/test/project/worktree-remove.test.ts

@@ -0,0 +1,126 @@
+import { $ } from "bun"
+import { describe, expect } from "bun:test"
+import * as fs from "fs/promises"
+import path from "path"
+import { Effect, Layer } from "effect"
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+import { Worktree } from "../../src/worktree"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(Layer.mergeAll(Worktree.defaultLayer, CrossSpawnSpawner.defaultLayer))
+const wintest = process.platform === "win32" ? it.live : it.live.skip
+
+describe("Worktree.remove", () => {
+  it.live("continues when git remove exits non-zero after detaching", () =>
+    provideTmpdirInstance(
+      (root) =>
+        Effect.gen(function* () {
+          const svc = yield* Worktree.Service
+          const name = `remove-regression-${Date.now().toString(36)}`
+          const branch = `opencode/${name}`
+          const dir = path.join(root, "..", name)
+
+          yield* Effect.promise(() => $`git worktree add --no-checkout -b ${branch} ${dir}`.cwd(root).quiet())
+          yield* Effect.promise(() => $`git reset --hard`.cwd(dir).quiet())
+
+          const real = (yield* Effect.promise(() => $`which git`.quiet().text())).trim()
+          expect(real).toBeTruthy()
+
+          const bin = path.join(root, "bin")
+          const shim = path.join(bin, "git")
+          yield* Effect.promise(() => fs.mkdir(bin, { recursive: true }))
+          yield* Effect.promise(() =>
+            Bun.write(
+              shim,
+              [
+                "#!/bin/bash",
+                `REAL_GIT=${JSON.stringify(real)}`,
+                'if [ "$1" = "worktree" ] && [ "$2" = "remove" ]; then',
+                '  "$REAL_GIT" "$@" >/dev/null 2>&1',
+                '  echo "fatal: failed to remove worktree: Directory not empty" >&2',
+                "  exit 1",
+                "fi",
+                'exec "$REAL_GIT" "$@"',
+              ].join("\n"),
+            ),
+          )
+          yield* Effect.promise(() => fs.chmod(shim, 0o755))
+
+          const prev = yield* Effect.acquireRelease(
+            Effect.sync(() => {
+              const prev = process.env.PATH ?? ""
+              process.env.PATH = `${bin}${path.delimiter}${prev}`
+              return prev
+            }),
+            (prev) =>
+              Effect.sync(() => {
+                process.env.PATH = prev
+              }),
+          )
+          void prev
+
+          const ok = yield* svc.remove({ directory: dir })
+
+          expect(ok).toBe(true)
+          expect(
+            yield* Effect.promise(() =>
+              fs
+                .stat(dir)
+                .then(() => true)
+                .catch(() => false),
+            ),
+          ).toBe(false)
+
+          const list = yield* Effect.promise(() => $`git worktree list --porcelain`.cwd(root).quiet().text())
+          expect(list).not.toContain(`worktree ${dir}`)
+
+          const ref = yield* Effect.promise(() =>
+            $`git show-ref --verify --quiet refs/heads/${branch}`.cwd(root).quiet().nothrow(),
+          )
+          expect(ref.exitCode).not.toBe(0)
+        }),
+      { git: true },
+    ),
+  )
+
+  wintest("stops fsmonitor before removing a worktree", () =>
+    provideTmpdirInstance(
+      (root) =>
+        Effect.gen(function* () {
+          const svc = yield* Worktree.Service
+          const name = `remove-fsmonitor-${Date.now().toString(36)}`
+          const branch = `opencode/${name}`
+          const dir = path.join(root, "..", name)
+
+          yield* Effect.promise(() => $`git worktree add --no-checkout -b ${branch} ${dir}`.cwd(root).quiet())
+          yield* Effect.promise(() => $`git reset --hard`.cwd(dir).quiet())
+          yield* Effect.promise(() => $`git config core.fsmonitor true`.cwd(dir).quiet())
+          yield* Effect.promise(() => $`git fsmonitor--daemon stop`.cwd(dir).quiet().nothrow())
+          yield* Effect.promise(() => Bun.write(path.join(dir, "tracked.txt"), "next\n"))
+          yield* Effect.promise(() => $`git diff`.cwd(dir).quiet())
+
+          const before = yield* Effect.promise(() => $`git fsmonitor--daemon status`.cwd(dir).quiet().nothrow())
+          expect(before.exitCode).toBe(0)
+
+          const ok = yield* svc.remove({ directory: dir })
+
+          expect(ok).toBe(true)
+          expect(
+            yield* Effect.promise(() =>
+              fs
+                .stat(dir)
+                .then(() => true)
+                .catch(() => false),
+            ),
+          ).toBe(false)
+
+          const ref = yield* Effect.promise(() =>
+            $`git show-ref --verify --quiet refs/heads/${branch}`.cwd(root).quiet().nothrow(),
+          )
+          expect(ref.exitCode).not.toBe(0)
+        }),
+      { git: true },
+    ),
+  )
+})

qimingcode/packages/opencode/test/project/worktree.test.ts

@@ -0,0 +1,214 @@
+import { $ } from "bun"
+import { afterEach, describe, expect } from "bun:test"
+import * as fs from "fs/promises"
+import path from "path"
+import { Cause, Effect, Exit, Layer } from "effect"
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+import { Instance } from "../../src/project/instance"
+import { Worktree } from "../../src/worktree"
+import { provideInstance, provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(Layer.mergeAll(Worktree.defaultLayer, CrossSpawnSpawner.defaultLayer))
+const wintest = process.platform !== "win32" ? it.live : it.live.skip
+
+function normalize(input: string) {
+  return input.replace(/\\/g, "/").toLowerCase()
+}
+
+async function waitReady() {
+  const { GlobalBus } = await import("../../src/bus/global")
+
+  return await new Promise<{ name: string; branch: string }>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      GlobalBus.off("event", on)
+      reject(new Error("timed out waiting for worktree.ready"))
+    }, 10_000)
+
+    function on(evt: { directory?: string; payload: { type: string; properties: { name: string; branch: string } } }) {
+      if (evt.payload.type !== Worktree.Event.Ready.type) return
+      clearTimeout(timer)
+      GlobalBus.off("event", on)
+      resolve(evt.payload.properties)
+    }
+
+    GlobalBus.on("event", on)
+  })
+}
+
+describe("Worktree", () => {
+  afterEach(() => Instance.disposeAll())
+
+  describe("makeWorktreeInfo", () => {
+    it.live("returns info with name, branch, and directory", () =>
+      provideTmpdirInstance(
+        () =>
+          Effect.gen(function* () {
+            const svc = yield* Worktree.Service
+            const info = yield* svc.makeWorktreeInfo()
+
+            expect(info.name).toBeDefined()
+            expect(typeof info.name).toBe("string")
+            expect(info.branch).toBe(`opencode/${info.name}`)
+            expect(info.directory).toContain(info.name)
+          }),
+        { git: true },
+      ),
+    )
+
+    it.live("uses provided name as base", () =>
+      provideTmpdirInstance(
+        () =>
+          Effect.gen(function* () {
+            const svc = yield* Worktree.Service
+            const info = yield* svc.makeWorktreeInfo("my-feature")
+
+            expect(info.name).toBe("my-feature")
+            expect(info.branch).toBe("opencode/my-feature")
+          }),
+        { git: true },
+      ),
+    )
+
+    it.live("slugifies the provided name", () =>
+      provideTmpdirInstance(
+        () =>
+          Effect.gen(function* () {
+            const svc = yield* Worktree.Service
+            const info = yield* svc.makeWorktreeInfo("My Feature Branch!")
+
+            expect(info.name).toBe("my-feature-branch")
+          }),
+        { git: true },
+      ),
+    )
+
+    it.live("throws NotGitError for non-git directories", () =>
+      provideTmpdirInstance(() =>
+        Effect.gen(function* () {
+          const svc = yield* Worktree.Service
+          const exit = yield* Effect.exit(svc.makeWorktreeInfo())
+
+          expect(Exit.isFailure(exit)).toBe(true)
+          if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Worktree.NotGitError)
+        }),
+      ),
+    )
+  })
+
+  describe("create + remove lifecycle", () => {
+    it.live("create returns worktree info and remove cleans up", () =>
+      provideTmpdirInstance(
+        () =>
+          Effect.gen(function* () {
+            const svc = yield* Worktree.Service
+            const info = yield* svc.create()
+
+            expect(info.name).toBeDefined()
+            expect(info.branch).toStartWith("opencode/")
+            expect(info.directory).toBeDefined()
+
+            yield* Effect.promise(() => Bun.sleep(1000))
+
+            const ok = yield* svc.remove({ directory: info.directory })
+            expect(ok).toBe(true)
+          }),
+        { git: true },
+      ),
+    )
+
+    it.live("create returns after setup and fires Event.Ready after bootstrap", () =>
+      provideTmpdirInstance(
+        (dir) =>
+          Effect.gen(function* () {
+            const svc = yield* Worktree.Service
+            const ready = waitReady()
+            const info = yield* svc.create()
+
+            expect(info.name).toBeDefined()
+            expect(info.branch).toStartWith("opencode/")
+
+            const text = yield* Effect.promise(() => $`git worktree list --porcelain`.cwd(dir).quiet().text())
+            const next = yield* Effect.promise(() => fs.realpath(info.directory).catch(() => info.directory))
+            expect(normalize(text)).toContain(normalize(next))
+
+            const props = yield* Effect.promise(() => ready)
+            expect(props.name).toBe(info.name)
+            expect(props.branch).toBe(info.branch)
+
+            yield* Effect.promise(() => Instance.dispose()).pipe(provideInstance(info.directory))
+            yield* Effect.promise(() => Bun.sleep(100))
+            yield* svc.remove({ directory: info.directory })
+          }),
+        { git: true },
+      ),
+    )
+
+    it.live("create with custom name", () =>
+      provideTmpdirInstance(
+        () =>
+          Effect.gen(function* () {
+            const svc = yield* Worktree.Service
+            const ready = waitReady()
+            const info = yield* svc.create({ name: "test-workspace" })
+
+            expect(info.name).toBe("test-workspace")
+            expect(info.branch).toBe("opencode/test-workspace")
+
+            yield* Effect.promise(() => ready)
+            yield* Effect.promise(() => Instance.dispose()).pipe(provideInstance(info.directory))
+            yield* Effect.promise(() => Bun.sleep(100))
+            yield* svc.remove({ directory: info.directory })
+          }),
+        { git: true },
+      ),
+    )
+  })
+
+  describe("createFromInfo", () => {
+    wintest("creates and bootstraps git worktree", () =>
+      provideTmpdirInstance(
+        (dir) =>
+          Effect.gen(function* () {
+            const svc = yield* Worktree.Service
+            const info = yield* svc.makeWorktreeInfo("from-info-test")
+            yield* svc.createFromInfo(info)
+
+            const list = yield* Effect.promise(() => $`git worktree list --porcelain`.cwd(dir).quiet().text())
+            const normalizedList = list.replace(/\\/g, "/")
+            const normalizedDir = info.directory.replace(/\\/g, "/")
+            expect(normalizedList).toContain(normalizedDir)
+
+            yield* svc.remove({ directory: info.directory })
+          }),
+        { git: true },
+      ),
+    )
+  })
+
+  describe("remove edge cases", () => {
+    it.live("remove non-existent directory succeeds silently", () =>
+      provideTmpdirInstance(
+        (dir) =>
+          Effect.gen(function* () {
+            const svc = yield* Worktree.Service
+            const ok = yield* svc.remove({ directory: path.join(dir, "does-not-exist") })
+            expect(ok).toBe(true)
+          }),
+        { git: true },
+      ),
+    )
+
+    it.live("throws NotGitError for non-git directories", () =>
+      provideTmpdirInstance(() =>
+        Effect.gen(function* () {
+          const svc = yield* Worktree.Service
+          const exit = yield* Effect.exit(svc.remove({ directory: "/tmp/fake" }))
+
+          expect(Exit.isFailure(exit)).toBe(true)
+          if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Worktree.NotGitError)
+        }),
+      ),
+    )
+  })
+})