@ronkovic/aad 0.3.0

package/src/modules/git-workspace/__tests__/merge-service.test.ts

@@ -0,0 +1,286 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { rm, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { MergeService } from "../merge-service";
+import { gitExec } from "../git-exec";
+import { createTaskId } from "@aad/shared/types";
+
+const TEST_DIR = join(import.meta.dir, ".tmp-merge-service-test");
+const REPO_DIR = join(TEST_DIR, "repo");
+const PARENT_WORKTREE = join(TEST_DIR, "parent-worktree");
+let DEFAULT_BRANCH = "main";
+
+/** Reset worktree to clean state before each test */
+async function resetWorktree(): Promise<MergeService> {
+  const mergeService = new MergeService({ repoRoot: REPO_DIR });
+
+  // Abort any in-progress merge
+  try {
+    await gitExec(["merge", "--abort"], { cwd: PARENT_WORKTREE });
+  } catch {
+    // No merge in progress
+  }
+  await gitExec(["checkout", DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+  await gitExec(["reset", "--hard", "origin/" + DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+  await gitExec(["clean", "-fd"], { cwd: PARENT_WORKTREE });
+
+  // Batch delete local task branches
+  try {
+    const branches = await gitExec(["branch", "--list", "task-*"], { cwd: PARENT_WORKTREE });
+    const names = branches.stdout
+      .split("\n")
+      .map((b) => b.trim().replace("* ", ""))
+      .filter((b) => b && b !== DEFAULT_BRANCH);
+    if (names.length > 0) {
+      await gitExec(["branch", "-D", ...names], { cwd: PARENT_WORKTREE });
+    }
+  } catch {
+    // Ignore
+  }
+
+  // Batch delete remote task branches from bare repo
+  try {
+    const refs = await gitExec(
+      ["for-each-ref", "--format=%(refname:short)", "refs/heads/task-*"],
+      { cwd: REPO_DIR }
+    );
+    const names = refs.stdout.split("\n").filter(Boolean);
+    if (names.length > 0) {
+      await gitExec(["branch", "-D", ...names], { cwd: REPO_DIR });
+    }
+  } catch {
+    // Ignore
+  }
+
+  return mergeService;
+}
+
+describe("MergeService", () => {
+  beforeAll(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+    await mkdir(REPO_DIR, { recursive: true });
+    await mkdir(PARENT_WORKTREE, { recursive: true });
+
+    // Initialize main repo with explicit branch
+    await gitExec(["init", "--bare"], { cwd: REPO_DIR });
+    await gitExec(["symbolic-ref", "HEAD", "refs/heads/main"], { cwd: REPO_DIR });
+
+    // Clone to parent worktree
+    await gitExec(["clone", REPO_DIR, PARENT_WORKTREE], { cwd: TEST_DIR });
+    await gitExec(["config", "user.name", "Test User"], { cwd: PARENT_WORKTREE });
+    await gitExec(["config", "user.email", "test@example.com"], { cwd: PARENT_WORKTREE });
+    await gitExec(["config", "commit.gpgsign", "false"], { cwd: PARENT_WORKTREE });
+
+    // Create initial commit
+    await Bun.write(join(PARENT_WORKTREE, "README.md"), "# Test Repo\n");
+    await gitExec(["add", "README.md"], { cwd: PARENT_WORKTREE });
+    await gitExec(["commit", "-m", "Initial commit"], { cwd: PARENT_WORKTREE });
+
+    const branchResult = await gitExec(["branch", "--show-current"], { cwd: PARENT_WORKTREE });
+    DEFAULT_BRANCH = branchResult.stdout.trim();
+
+    await gitExec(["push", "origin", "HEAD"], { cwd: PARENT_WORKTREE });
+  }, 30_000);
+
+  afterAll(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("mergeToParent", () => {
+    test("successfully merges task branch without conflicts", async () => {
+      const mergeService = await resetWorktree();
+
+      const taskBranch = "task-feature-1";
+      await gitExec(["checkout", "-b", taskBranch], { cwd: PARENT_WORKTREE });
+      await Bun.write(join(PARENT_WORKTREE, "feature.ts"), "export const feature = 1;\n");
+      await gitExec(["add", "feature.ts"], { cwd: PARENT_WORKTREE });
+      await gitExec(["commit", "-m", "Add feature"], { cwd: PARENT_WORKTREE });
+      await gitExec(["push", "origin", taskBranch], { cwd: PARENT_WORKTREE });
+
+      await gitExec(["checkout", "HEAD~1"], { cwd: PARENT_WORKTREE });
+
+      const result = await mergeService.mergeToParent(
+        createTaskId("task-1"),
+        taskBranch,
+        DEFAULT_BRANCH,
+        PARENT_WORKTREE
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.conflicts).toBeUndefined();
+      expect(result.message).toContain("Successfully merged");
+    }, 60_000);
+
+    test("detects merge conflicts and aborts merge", async () => {
+      const mergeService = await resetWorktree();
+
+      await gitExec(["checkout", DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+      await Bun.write(join(PARENT_WORKTREE, "conflict.ts"), "export const version = 1;\n");
+      await gitExec(["add", "conflict.ts"], { cwd: PARENT_WORKTREE });
+      await gitExec(["commit", "-m", "Add conflict file in main"], { cwd: PARENT_WORKTREE });
+
+      const taskBranch = "task-conflict";
+      await gitExec(["checkout", "HEAD~1"], { cwd: PARENT_WORKTREE });
+      await gitExec(["checkout", "-b", taskBranch], { cwd: PARENT_WORKTREE });
+      await Bun.write(join(PARENT_WORKTREE, "conflict.ts"), "export const version = 2;\n");
+      await gitExec(["add", "conflict.ts"], { cwd: PARENT_WORKTREE });
+      await gitExec(["commit", "-m", "Add conflict file in task"], { cwd: PARENT_WORKTREE });
+      await gitExec(["push", "origin", taskBranch], { cwd: PARENT_WORKTREE });
+
+      await gitExec(["checkout", DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+
+      const result = await mergeService.mergeToParent(
+        createTaskId("task-conflict"),
+        taskBranch,
+        DEFAULT_BRANCH,
+        PARENT_WORKTREE
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.conflicts).toBeDefined();
+      expect(result.conflicts?.length).toBeGreaterThan(0);
+      expect(result.conflicts).toContain("conflict.ts");
+      expect(result.message).toContain("Merge conflict");
+    }, 60_000);
+  });
+
+  describe("detectConflicts", () => {
+    test("returns empty array when no conflicts", async () => {
+      await resetWorktree();
+      const mergeService = new MergeService({ repoRoot: REPO_DIR });
+
+      const conflicts = await mergeService.detectConflicts(PARENT_WORKTREE);
+      expect(conflicts).toEqual([]);
+    }, 30_000);
+
+    test("returns conflicted files list", async () => {
+      const mergeService = await resetWorktree();
+
+      await gitExec(["checkout", DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+      const taskBranch = "task-detect-conflict";
+      await gitExec(["checkout", "-b", taskBranch], { cwd: PARENT_WORKTREE });
+      await Bun.write(join(PARENT_WORKTREE, "detect.ts"), "const value = 1;\n");
+      await gitExec(["add", "detect.ts"], { cwd: PARENT_WORKTREE });
+      await gitExec(["commit", "-m", "Task version"], { cwd: PARENT_WORKTREE });
+
+      await gitExec(["checkout", DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+      await Bun.write(join(PARENT_WORKTREE, "detect.ts"), "const value = 2;\n");
+      await gitExec(["add", "detect.ts"], { cwd: PARENT_WORKTREE });
+      await gitExec(["commit", "-m", "Main version"], { cwd: PARENT_WORKTREE });
+
+      try {
+        await gitExec(["merge", "--no-ff", taskBranch], { cwd: PARENT_WORKTREE });
+      } catch {
+        // Expected to fail
+      }
+
+      const conflicts = await mergeService.detectConflicts(PARENT_WORKTREE);
+
+      expect(conflicts.length).toBeGreaterThan(0);
+      expect(conflicts).toContain("detect.ts");
+
+      await gitExec(["merge", "--abort"], { cwd: PARENT_WORKTREE });
+    }, 60_000);
+  });
+
+  describe("fetchDependencyChanges", () => {
+    test("fetches and merges dependency branch", async () => {
+      await resetWorktree();
+      const mergeService = new MergeService({ repoRoot: REPO_DIR });
+
+      const depBranch = "task-dependency";
+      await gitExec(["checkout", DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+      await gitExec(["checkout", "-b", depBranch], { cwd: PARENT_WORKTREE });
+      await Bun.write(join(PARENT_WORKTREE, "dep.ts"), "export const dep = true;\n");
+      await gitExec(["add", "dep.ts"], { cwd: PARENT_WORKTREE });
+      await gitExec(["commit", "-m", "Add dependency"], { cwd: PARENT_WORKTREE });
+      await gitExec(["push", "origin", depBranch], { cwd: PARENT_WORKTREE });
+
+      await gitExec(["checkout", DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+      await gitExec(["checkout", "-b", "task-target"], { cwd: PARENT_WORKTREE });
+
+      await mergeService.fetchDependencyChanges(depBranch, PARENT_WORKTREE);
+
+      const depFile = Bun.file(join(PARENT_WORKTREE, "dep.ts"));
+      const exists = await depFile.exists();
+      expect(exists).toBe(true);
+    }, 60_000);
+  });
+
+  describe("getChangedFiles", () => {
+    test("returns list of changed files", async () => {
+      await resetWorktree();
+      const mergeService = new MergeService({ repoRoot: REPO_DIR });
+
+      const testBranch = "task-changes";
+      await gitExec(["checkout", DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+      await gitExec(["checkout", "-b", testBranch], { cwd: PARENT_WORKTREE });
+
+      await Bun.write(join(PARENT_WORKTREE, "change1.ts"), "// Change 1\n");
+      await Bun.write(join(PARENT_WORKTREE, "change2.ts"), "// Change 2\n");
+      await gitExec(["add", "change1.ts", "change2.ts"], { cwd: PARENT_WORKTREE });
+      await gitExec(["commit", "-m", "Add changes"], { cwd: PARENT_WORKTREE });
+      await gitExec(["push", "origin", testBranch], { cwd: PARENT_WORKTREE });
+
+      const files = await mergeService.getChangedFiles(testBranch, DEFAULT_BRANCH);
+
+      expect(files).toContain("change1.ts");
+      expect(files).toContain("change2.ts");
+      expect(files.length).toBeGreaterThanOrEqual(2);
+    }, 60_000);
+
+    test("returns empty array when no changes", async () => {
+      await resetWorktree();
+      const mergeService = new MergeService({ repoRoot: REPO_DIR });
+
+      const files = await mergeService.getChangedFiles(DEFAULT_BRANCH, DEFAULT_BRANCH);
+      expect(files).toEqual([]);
+    }, 30_000);
+  });
+
+  describe("hasConflictingChanges", () => {
+    test("detects conflicting and non-conflicting changes", async () => {
+      const mergeService = await resetWorktree();
+
+      await gitExec(["checkout", DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+      const baseCommit = await gitExec(["rev-parse", "HEAD"], { cwd: PARENT_WORKTREE });
+      const baseRef = baseCommit.stdout.trim();
+
+      // Branch 1: modifies shared.ts + unique file
+      const branch1 = "task-conflict-check-1";
+      await gitExec(["checkout", "-b", branch1, baseRef], { cwd: PARENT_WORKTREE });
+      await Bun.write(join(PARENT_WORKTREE, "shared.ts"), "const v = 1;\n");
+      await Bun.write(join(PARENT_WORKTREE, "only-in-branch1.ts"), "// Only in branch 1\n");
+      await gitExec(["add", "shared.ts", "only-in-branch1.ts"], { cwd: PARENT_WORKTREE });
+      await gitExec(["commit", "-m", "Branch 1 changes"], { cwd: PARENT_WORKTREE });
+      await gitExec(["push", "origin", branch1], { cwd: PARENT_WORKTREE });
+
+      // Branch 2: modifies shared.ts (conflict) + unique file (no conflict)
+      await gitExec(["checkout", baseRef], { cwd: PARENT_WORKTREE });
+      const branch2 = "task-conflict-check-2";
+      await gitExec(["checkout", "-b", branch2], { cwd: PARENT_WORKTREE });
+      await Bun.write(join(PARENT_WORKTREE, "shared.ts"), "const v = 2;\n");
+      await Bun.write(join(PARENT_WORKTREE, "only-in-branch2.ts"), "// Only in branch 2\n");
+      await gitExec(["add", "shared.ts", "only-in-branch2.ts"], { cwd: PARENT_WORKTREE });
+      await gitExec(["commit", "-m", "Branch 2 changes"], { cwd: PARENT_WORKTREE });
+      await gitExec(["push", "origin", branch2], { cwd: PARENT_WORKTREE });
+
+      // Branch 3: only unique file (no overlap with branch1)
+      await gitExec(["checkout", baseRef], { cwd: PARENT_WORKTREE });
+      const branch3 = "task-conflict-check-3";
+      await gitExec(["checkout", "-b", branch3], { cwd: PARENT_WORKTREE });
+      await Bun.write(join(PARENT_WORKTREE, "only-in-branch3.ts"), "// Only in branch 3\n");
+      await gitExec(["add", "only-in-branch3.ts"], { cwd: PARENT_WORKTREE });
+      await gitExec(["commit", "-m", "Branch 3 unique file"], { cwd: PARENT_WORKTREE });
+      await gitExec(["push", "origin", branch3], { cwd: PARENT_WORKTREE });
+
+      // Branches 1 & 2 both modify shared.ts → conflict
+      const hasConflict = await mergeService.hasConflictingChanges(branch1, branch2, baseRef);
+      expect(hasConflict).toBe(true);
+
+      // Branches 1 & 3 modify different files → no conflict
+      const noConflict = await mergeService.hasConflictingChanges(branch1, branch3, baseRef);
+      expect(noConflict).toBe(false);
+    }, 90_000);
+  });
+});

package/src/modules/git-workspace/__tests__/settings-merge.test.ts

@@ -0,0 +1,163 @@
+import { describe, test, expect } from "bun:test";
+import { mergeSettings } from "../settings-merge";
+import type { ClaudeSettings } from "../settings-merge";
+
+describe("settings-merge", () => {
+  describe("mergeSettings", () => {
+    test("merges simple objects", () => {
+      const base: ClaudeSettings = {
+        debug: false,
+        timeout: 30000,
+      };
+
+      const override: ClaudeSettings = {
+        debug: true,
+        workers: 4,
+      };
+
+      const merged = mergeSettings(base, override);
+
+      expect(merged.debug).toBe(true);
+      expect(merged.timeout).toBe(30000);
+      expect(merged.workers).toBe(4);
+    });
+
+    test("performs deep merge for nested objects", () => {
+      const base: ClaudeSettings = {
+        models: {
+          default: "sonnet",
+          tester: "haiku",
+        },
+      };
+
+      const override: ClaudeSettings = {
+        models: {
+          default: "opus",
+          reviewer: "sonnet",
+        },
+      };
+
+      const merged = mergeSettings(base, override);
+
+      expect(merged.models).toEqual({
+        default: "opus",
+        tester: "haiku",
+        reviewer: "sonnet",
+      });
+    });
+
+    test("unions arrays (deduplicates)", () => {
+      const base: ClaudeSettings = {
+        permissions: ["read", "write"] as unknown as Record<string, unknown>,
+      };
+
+      const override: ClaudeSettings = {
+        permissions: ["write", "execute"] as unknown as Record<string, unknown>,
+      };
+
+      const merged = mergeSettings(base, override);
+
+      expect(Array.isArray(merged.permissions)).toBe(true);
+      expect(merged.permissions).toHaveLength(3);
+      expect(merged.permissions).toEqual(expect.arrayContaining(["read", "write", "execute"]));
+    });
+
+    test("overrides primitives", () => {
+      const base: ClaudeSettings = {
+        timeout: 10000,
+        enabled: false,
+      };
+
+      const override: ClaudeSettings = {
+        timeout: 20000,
+        enabled: true,
+      };
+
+      const merged = mergeSettings(base, override);
+
+      expect(merged.timeout).toBe(20000);
+      expect(merged.enabled).toBe(true);
+    });
+
+    test("handles undefined and null values", () => {
+      const base: ClaudeSettings = {
+        debug: true,
+        timeout: 30000,
+      };
+
+      const override: ClaudeSettings = {
+        debug: undefined,
+        timeout: null as any,
+        workers: 4,
+      };
+
+      const merged = mergeSettings(base, override);
+
+      expect(merged.debug).toBe(true);
+      expect(merged.timeout).toBe(30000);
+      expect(merged.workers).toBe(4);
+    });
+
+    test("handles complex nested structure", () => {
+      const base: ClaudeSettings = {
+        env: {
+          PATH: "/usr/bin",
+          HOME: "/home/user",
+        },
+        hooks: {
+          preCommit: ["lint", "test"],
+        },
+      };
+
+      const override: ClaudeSettings = {
+        env: {
+          PATH: "/usr/local/bin",
+          NODE_ENV: "production",
+        },
+        hooks: {
+          preCommit: ["test", "build"],
+          postCommit: ["deploy"],
+        },
+      };
+
+      const merged = mergeSettings(base, override);
+
+      expect(merged.env).toEqual({
+        PATH: "/usr/local/bin",
+        HOME: "/home/user",
+        NODE_ENV: "production",
+      });
+
+      expect(merged.hooks).toEqual({
+        preCommit: expect.arrayContaining(["lint", "test", "build"]),
+        postCommit: ["deploy"],
+      });
+    });
+
+    test("preserves base when override is empty", () => {
+      const base: ClaudeSettings = {
+        debug: true,
+        timeout: 30000,
+      };
+
+      const override: ClaudeSettings = {};
+
+      const merged = mergeSettings(base, override);
+
+      expect(merged).toEqual(base);
+    });
+
+    test("uses override when base is empty", () => {
+      const base: ClaudeSettings = {};
+
+      const override: ClaudeSettings = {
+        debug: true,
+        timeout: 30000,
+      };
+
+      const merged = mergeSettings(base, override);
+
+      expect(merged).toEqual(override);
+    });
+  });
+});

package/src/modules/git-workspace/__tests__/worktree-manager.test.ts

@@ -0,0 +1,247 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test";
+import { WorktreeManager } from "../worktree-manager";
+import { createTaskId, createRunId } from "@aad/shared/types";
+import { GitWorkspaceError } from "@aad/shared/errors";
+import { pino } from "pino";
+import type { GitOps } from "../git-exec";
+import type { WorktreeManagerFsOps } from "../worktree-manager";
+
+describe("WorktreeManager", () => {
+  let worktreeManager: WorktreeManager;
+  const repoRoot = "/test/repo";
+  const worktreeBase = "/test/worktrees";
+
+  let mockGitOps: GitOps;
+  let mockFsOps: WorktreeManagerFsOps;
+
+  beforeEach(() => {
+    mockGitOps = {
+      gitExec: mock(async () => ({ stdout: "", stderr: "", exitCode: 0 })),
+      branchExists: mock(async () => false),
+    };
+    mockFsOps = {
+      mkdir: mock(async () => undefined) as any,
+      rm: mock(async () => {}) as any,
+    };
+
+    worktreeManager = new WorktreeManager({
+      repoRoot,
+      worktreeBase,
+      logger: pino({ level: "silent" }),
+      gitOps: mockGitOps,
+      fsOps: mockFsOps,
+    });
+  });
+
+  describe("createTaskWorktree", () => {
+    test("creates worktree with new branch", async () => {
+      const taskId = createTaskId("task-001");
+      const branch = "task/001-feature";
+
+      const worktreePath = await worktreeManager.createTaskWorktree(taskId, branch);
+
+      expect(worktreePath).toBe("/test/worktrees/task-001");
+      expect(mockFsOps.mkdir).toHaveBeenCalledWith(worktreeBase, { recursive: true });
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["worktree", "add", "-b", branch, "/test/worktrees/task-001", "HEAD"],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("throws GitWorkspaceError on failure", async () => {
+      const taskId = createTaskId("task-002");
+      const branch = "task/002-fail";
+
+      mockGitOps.gitExec = mock(() => Promise.reject(new Error("git worktree add failed")));
+
+      await expect(
+        worktreeManager.createTaskWorktree(taskId, branch)
+      ).rejects.toThrow(GitWorkspaceError);
+    });
+
+    test("ensures worktree base directory exists", async () => {
+      const taskId = createTaskId("task-003");
+      const branch = "task/003-new";
+
+      await worktreeManager.createTaskWorktree(taskId, branch);
+
+      expect(mockFsOps.mkdir).toHaveBeenCalledTimes(1);
+      expect(mockFsOps.mkdir).toHaveBeenCalledWith(worktreeBase, { recursive: true });
+    });
+  });
+
+  describe("createParentWorktree", () => {
+    test("creates worktree on existing branch", async () => {
+      const runId = createRunId("run-001");
+      const parentBranch = "main";
+
+      const worktreePath = await worktreeManager.createParentWorktree(runId, parentBranch);
+
+      expect(worktreePath).toBe("/test/worktrees/parent-run-001");
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["worktree", "add", "/test/worktrees/parent-run-001", parentBranch],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("throws GitWorkspaceError on failure", async () => {
+      const runId = createRunId("run-002");
+      const parentBranch = "main";
+
+      mockGitOps.gitExec = mock(() => Promise.reject(new Error("branch not found")));
+
+      await expect(
+        worktreeManager.createParentWorktree(runId, parentBranch)
+      ).rejects.toThrow(GitWorkspaceError);
+    });
+  });
+
+  describe("removeWorktree", () => {
+    test("removes worktree successfully", async () => {
+      const worktreePath = "/test/worktrees/task-001";
+
+      await worktreeManager.removeWorktree(worktreePath);
+
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["worktree", "remove", worktreePath],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("removes worktree with force flag", async () => {
+      const worktreePath = "/test/worktrees/task-002";
+
+      await worktreeManager.removeWorktree(worktreePath, true);
+
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["worktree", "remove", worktreePath, "--force"],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+
+    test("ignores error if worktree already removed", async () => {
+      const worktreePath = "/test/worktrees/task-003";
+
+      const error = new GitWorkspaceError("git error", {
+        stderr: "error: 'task-003' is not a working tree",
+      });
+      mockGitOps.gitExec = mock(() => Promise.reject(error));
+
+      await expect(worktreeManager.removeWorktree(worktreePath)).resolves.toBeUndefined();
+    });
+
+    test("attempts fallback cleanup on failure", async () => {
+      const worktreePath = "/test/worktrees/task-004";
+
+      let callCount = 0;
+      mockGitOps.gitExec = mock(async () => {
+        callCount++;
+        if (callCount === 1) {
+          throw new Error("git worktree remove failed");
+        }
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      await expect(worktreeManager.removeWorktree(worktreePath)).rejects.toThrow(
+        GitWorkspaceError
+      );
+
+      expect(mockFsOps.rm).toHaveBeenCalledWith(worktreePath, { recursive: true, force: true });
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["worktree", "prune"],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+  });
+
+  describe("listWorktrees", () => {
+    test("parses worktree list output", async () => {
+      const porcelainOutput = `worktree /test/repo
+HEAD abc123
+branch refs/heads/main
+
+worktree /test/worktrees/task-001
+HEAD def456
+branch refs/heads/task/001-feature
+
+worktree /test/worktrees/task-002
+HEAD 789ghi
+
+`;
+
+      mockGitOps.gitExec = mock(async () => ({
+        stdout: porcelainOutput,
+        stderr: "",
+        exitCode: 0
+      }));
+
+      const worktrees = await worktreeManager.listWorktrees();
+
+      expect(worktrees).toHaveLength(3);
+      expect(worktrees[0]).toEqual({
+        path: "/test/repo",
+        branch: "refs/heads/main",
+        head: "abc123",
+      });
+      expect(worktrees[1]).toEqual({
+        path: "/test/worktrees/task-001",
+        branch: "refs/heads/task/001-feature",
+        head: "def456",
+      });
+      expect(worktrees[2]).toEqual({
+        path: "/test/worktrees/task-002",
+        branch: "(detached)",
+        head: "789ghi",
+      });
+    });
+
+    test("returns empty array when no worktrees", async () => {
+      mockGitOps.gitExec = mock(async () => ({ stdout: "", stderr: "", exitCode: 0 }));
+
+      const worktrees = await worktreeManager.listWorktrees();
+
+      expect(worktrees).toEqual([]);
+    });
+  });
+
+  describe("verifyWorktree", () => {
+    test("returns true for valid worktree", async () => {
+      const worktreePath = "/test/worktrees/task-001";
+
+      mockGitOps.gitExec = mock(async () => ({
+        stdout: "/test/worktrees/task-001/.git",
+        stderr: "",
+        exitCode: 0,
+      }));
+
+      const isValid = await worktreeManager.verifyWorktree(worktreePath);
+
+      expect(isValid).toBe(true);
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["rev-parse", "--git-dir"],
+        expect.objectContaining({ cwd: worktreePath })
+      );
+    });
+
+    test("returns false for invalid worktree", async () => {
+      const worktreePath = "/test/worktrees/invalid";
+
+      mockGitOps.gitExec = mock(() => Promise.reject(new Error("not a git repository")));
+
+      const isValid = await worktreeManager.verifyWorktree(worktreePath);
+
+      expect(isValid).toBe(false);
+    });
+  });
+
+  describe("pruneWorktrees", () => {
+    test("runs git worktree prune", async () => {
+      await worktreeManager.pruneWorktrees();
+
+      expect(mockGitOps.gitExec).toHaveBeenCalledWith(
+        ["worktree", "prune"],
+        expect.objectContaining({ cwd: repoRoot })
+      );
+    });
+  });
+});