@ronkovic/aad 0.3.9 → 0.5.0

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

@@ -199,6 +199,58 @@ describe("BranchManager", () => {
       );
     });
 
+    test("excludes branches matching excludePatterns (default: /parent)", async () => {
+      const branches = ["feat/run-001/task-001", "feat/run-001/parent", "aad-task-x"];
+      let callCount = 0;
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        callCount++;
+        if (args[0] === "branch" && args[1] === "--list") {
+          // Only return branches for the first conventional prefix pattern
+          if (callCount === 1) {
+            return { stdout: branches.slice(0, 2).join("\n"), stderr: "", exitCode: 0 };
+          }
+          // aad-* pattern
+          if (args[2] === "aad-*") {
+            return { stdout: branches[2] ?? "", stderr: "", exitCode: 0 };
+          }
+          return { stdout: "", stderr: "", exitCode: 0 };
+        }
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      const deleted = await branchManager.cleanupOrphanBranches();
+      // feat/run-001/parent はスキップ、他2つは削除
+      expect(deleted).not.toContain("feat/run-001/parent");
+      expect(deleted.length).toBe(2);
+    });
+
+    test("deletes all branches when excludePatterns is empty array", async () => {
+      const branches = ["feat/run-001/parent", "feat/run-001/task-001"];
+      mockGitOps.gitExec = mock(async (args: string[]) => {
+        if (args[0] === "branch" && args[1] === "--list") {
+          if (args[2]?.startsWith("feat/")) {
+            return { stdout: branches.join("\n"), stderr: "", exitCode: 0 };
+          }
+          return { stdout: "", stderr: "", exitCode: 0 };
+        }
+        return { stdout: "", stderr: "", exitCode: 0 };
+      });
+
+      const deleted = await branchManager.cleanupOrphanBranches(undefined, {
+        force: false,
+        excludePatterns: [],
+      });
+      // parent含めて全削除
+      expect(deleted).toContain("feat/run-001/parent");
+    });
+
+    test("supports legacy boolean argument (backward compat)", async () => {
+      mockGitOps.gitExec = mock(async () => ({ stdout: "", stderr: "", exitCode: 0 }));
+      const deleted = await branchManager.cleanupOrphanBranches(undefined, true);
+      expect(deleted).toEqual([]);
+      // No error = backward compat OK
+    });
+
     test("cleans up orphan branches for specific runId", async () => {
       const runId = createRunId("run-001");
       const branches = ["aad-task-run-001-01", "aad-run-run-001"];

package/src/modules/git-workspace/__tests__/dependency-installer.test.ts

@@ -0,0 +1,77 @@
+import { describe, test, expect } from "bun:test";
+import { buildInstallCommand } from "../dependency-installer";
+import type { WorkspaceInfo } from "../../../shared/types";
+
+describe("buildInstallCommand", () => {
+  // Helper to create minimal WorkspaceInfo
+  const createWorkspace = (packageManager: WorkspaceInfo["packageManager"]): WorkspaceInfo => ({
+    path: "/tmp/test",
+    language: "typescript",
+    packageManager,
+    framework: "none",
+    testFramework: "bun-test",
+  });
+
+  describe("Node.js ecosystem", () => {
+    test("bun → bun install --frozen-lockfile", () => {
+      const result = buildInstallCommand(createWorkspace("bun"));
+      expect(result).toEqual(["bun", "install", "--frozen-lockfile"]);
+    });
+
+    test("npm → npm ci", () => {
+      const result = buildInstallCommand(createWorkspace("npm"));
+      expect(result).toEqual(["npm", "ci"]);
+    });
+
+    test("yarn → yarn install --frozen-lockfile", () => {
+      const result = buildInstallCommand(createWorkspace("yarn"));
+      expect(result).toEqual(["yarn", "install", "--frozen-lockfile"]);
+    });
+
+    test("pnpm → pnpm install --frozen-lockfile", () => {
+      const result = buildInstallCommand(createWorkspace("pnpm"));
+      expect(result).toEqual(["pnpm", "install", "--frozen-lockfile"]);
+    });
+  });
+
+  describe("Python ecosystem", () => {
+    test("uv → uv sync", () => {
+      const result = buildInstallCommand(createWorkspace("uv"));
+      expect(result).toEqual(["uv", "sync"]);
+    });
+
+    test("poetry → poetry install --no-interaction", () => {
+      const result = buildInstallCommand(createWorkspace("poetry"));
+      expect(result).toEqual(["poetry", "install", "--no-interaction"]);
+    });
+
+    test("pipenv → pipenv install", () => {
+      const result = buildInstallCommand(createWorkspace("pipenv"));
+      expect(result).toEqual(["pipenv", "install"]);
+    });
+
+    test("pip → pip install -r requirements.txt", () => {
+      const result = buildInstallCommand(createWorkspace("pip"));
+      expect(result).toEqual(["pip", "install", "-r", "requirements.txt"]);
+    });
+  });
+
+  describe("Go/Rust ecosystem", () => {
+    test("go → go mod download", () => {
+      const result = buildInstallCommand(createWorkspace("go"));
+      expect(result).toEqual(["go", "mod", "download"]);
+    });
+
+    test("cargo → cargo fetch", () => {
+      const result = buildInstallCommand(createWorkspace("cargo"));
+      expect(result).toEqual(["cargo", "fetch"]);
+    });
+  });
+
+  describe("Unknown/No-op package managers", () => {
+    test("unknown → null", () => {
+      const result = buildInstallCommand(createWorkspace("unknown"));
+      expect(result).toBeNull();
+    });
+  });
+});

package/src/modules/git-workspace/__tests__/git-exec.test.ts

@@ -88,4 +88,30 @@ describe("git-exec", () => {
       expect(exists).toBe(false);
     });
   });
+
+  describe("allowNonZeroExit option", () => {
+    test("does not throw on non-zero exit when allowNonZeroExit is true", async () => {
+      // git diff --cached --quiet は変更なしで exit 0
+      const result = await gitExec(["diff", "--cached", "--quiet"], {
+        cwd: TEST_DIR,
+        allowNonZeroExit: true,
+      });
+      expect(result.exitCode).toBe(0);
+    });
+
+    test("returns non-zero exitCode without throwing", async () => {
+      // 存在しないref → exit 128
+      const result = await gitExec(["rev-parse", "--verify", "nonexistent-ref"], {
+        cwd: TEST_DIR,
+        allowNonZeroExit: true,
+      });
+      expect(result.exitCode).not.toBe(0);
+    });
+
+    test("still throws when allowNonZeroExit is false (default)", async () => {
+      await expect(
+        gitExec(["rev-parse", "--verify", "nonexistent-ref"], { cwd: TEST_DIR })
+      ).rejects.toThrow("Git command failed");
+    });
+  });
 });

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

@@ -111,6 +111,25 @@ describe("MergeService", () => {
       expect(result.message).toContain("Successfully merged");
     }, 60_000);
 
+    test("sets alreadyUpToDate when task branch has no new commits", async () => {
+      const mergeService = await resetWorktree();
+
+      // taskBranch = 現在のHEADと同じ → Already up to date
+      const taskBranch = "task-no-changes";
+      await gitExec(["checkout", DEFAULT_BRANCH], { cwd: PARENT_WORKTREE });
+      await gitExec(["branch", taskBranch], { cwd: PARENT_WORKTREE });
+
+      const result = await mergeService.mergeToParent(
+        createTaskId("task-noop"),
+        taskBranch,
+        DEFAULT_BRANCH,
+        PARENT_WORKTREE
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.alreadyUpToDate).toBe(true);
+    }, 60_000);
+
     test("detects merge conflicts and aborts merge", async () => {
       const mergeService = await resetWorktree();
 

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

@@ -0,0 +1,80 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { PrManager } from "../pr-manager";
+import type { PrManagerOptions, DraftPrOptions } from "../pr-manager";
+import { GitWorkspaceError } from "@aad/shared/errors";
+
+describe("PrManager", () => {
+  let options: PrManagerOptions;
+
+  beforeEach(() => {
+    options = {
+      repoRoot: process.cwd(),
+    };
+  });
+
+  test("should create instance", () => {
+    const manager = new PrManager(options);
+    expect(manager).toBeDefined();
+  });
+
+  test("should check gh installation", async () => {
+    const manager = new PrManager(options);
+    const installed = await manager.checkGhInstalled();
+    // May be true or false depending on environment
+    expect(typeof installed).toBe("boolean");
+  });
+
+  test("should throw error if gh not installed when creating draft PR", async () => {
+    const manager = new PrManager(options);
+
+    // Mock checkGhInstalled to return false
+    manager.checkGhInstalled = async () => false;
+
+    const draftOptions: DraftPrOptions = {
+      title: "Test PR",
+      body: "Test body",
+      baseBranch: "main",
+      headBranch: "feature/test",
+    };
+
+    await expect(manager.createDraftPr(draftOptions)).rejects.toThrow(GitWorkspaceError);
+  });
+
+  test("should throw error if gh not installed when marking PR ready", async () => {
+    const manager = new PrManager(options);
+
+    // Mock checkGhInstalled to return false
+    manager.checkGhInstalled = async () => false;
+
+    await expect(manager.markPrReady(123)).rejects.toThrow(GitWorkspaceError);
+  });
+
+  test("should return null for getPrInfo if gh not installed", async () => {
+    const manager = new PrManager(options);
+
+    // Mock checkGhInstalled to return false
+    manager.checkGhInstalled = async () => false;
+
+    const result = await manager.getPrInfo(123);
+    expect(result).toBeNull();
+  });
+
+  test("should return null for findPrByBranch if gh not installed", async () => {
+    const manager = new PrManager(options);
+
+    // Mock checkGhInstalled to return false
+    manager.checkGhInstalled = async () => false;
+
+    const result = await manager.findPrByBranch("feature/test");
+    expect(result).toBeNull();
+  });
+
+  test("should throw error if gh not installed when closing PR", async () => {
+    const manager = new PrManager(options);
+
+    // Mock checkGhInstalled to return false
+    manager.checkGhInstalled = async () => false;
+
+    await expect(manager.closePr(123)).rejects.toThrow(GitWorkspaceError);
+  });
+});

package/src/modules/git-workspace/__tests__/template-copy.test.ts

@@ -0,0 +1,189 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { copyTemplatesToWorktree, resolveTemplateDir } from "../template-copy";
+import { createLogger } from "../../logging";
+
+const testDir = join(import.meta.dir, ".tmp-template-copy-test");
+const projectRoot = join(testDir, "project");
+const templateDir = join(projectRoot, ".aad", "templates");
+const targetDir = join(testDir, "target");
+
+const logger = createLogger({ service: "test", debug: false });
+
+beforeEach(async () => {
+  // Clean up test directory
+  await rm(testDir, { recursive: true, force: true });
+  await mkdir(testDir, { recursive: true });
+  await mkdir(projectRoot, { recursive: true });
+  await mkdir(templateDir, { recursive: true });
+  await mkdir(targetDir, { recursive: true });
+});
+
+describe("copyTemplatesToWorktree", () => {
+  test("copies CLAUDE.md with project append", async () => {
+    // Setup template and project CLAUDE.md
+    await writeFile(join(templateDir, "CLAUDE.md"), "# Template Context\n\nTemplate content.");
+    await writeFile(join(projectRoot, "CLAUDE.md"), "# Project Context\n\nProject content.");
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    const targetCLAUDE = await Bun.file(join(targetDir, "CLAUDE.md")).text();
+    expect(targetCLAUDE).toContain("Template content");
+    expect(targetCLAUDE).toContain("# プロジェクト固有コンテキスト");
+    expect(targetCLAUDE).toContain("Project content");
+  });
+
+  test("handles missing template CLAUDE.md", async () => {
+    // Only project CLAUDE.md
+    await writeFile(join(projectRoot, "CLAUDE.md"), "Project only.");
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    const targetCLAUDE = await Bun.file(join(targetDir, "CLAUDE.md")).text();
+    expect(targetCLAUDE).toContain("# プロジェクト固有コンテキスト");
+    expect(targetCLAUDE).toContain("Project only");
+  });
+
+  test("copies .claude/ with overlay merge", async () => {
+    // Setup project .claude/rules
+    await mkdir(join(projectRoot, ".claude", "rules"), { recursive: true });
+    await writeFile(join(projectRoot, ".claude", "rules", "project.md"), "Project rule");
+
+    // Setup template .claude/rules (should overlay)
+    await mkdir(join(templateDir, ".claude", "rules"), { recursive: true });
+    await writeFile(join(templateDir, ".claude", "rules", "template.md"), "Template rule");
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    // Both should exist
+    const projectRule = await Bun.file(join(targetDir, ".claude", "rules", "project.md")).text();
+    const templateRule = await Bun.file(join(targetDir, ".claude", "rules", "template.md")).text();
+
+    expect(projectRule).toBe("Project rule");
+    expect(templateRule).toBe("Template rule");
+  });
+
+  test("merges settings.json", async () => {
+    // Setup project settings
+    await mkdir(join(projectRoot, ".claude"), { recursive: true });
+    await writeFile(
+      join(projectRoot, ".claude", "settings.json"),
+      JSON.stringify({ permissions: { allow: ["read"] } })
+    );
+
+    // Setup template settings (now at root level, not in .claude/)
+    await writeFile(
+      join(templateDir, "settings.json"),
+      JSON.stringify({ permissions: { deny: ["write"] } })
+    );
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    const targetSettings = JSON.parse(
+      await Bun.file(join(targetDir, ".claude", "settings.json")).text()
+    );
+
+    expect(targetSettings.permissions).toBeDefined();
+    expect(targetSettings.permissions.allow).toEqual(["read"]);
+    expect(targetSettings.permissions.deny).toEqual(["write"]);
+  });
+
+  test("copies .gitignore from template", async () => {
+    await writeFile(join(templateDir, ".gitignore"), "node_modules/\n*.log");
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    const gitignore = await Bun.file(join(targetDir, ".gitignore")).text();
+    expect(gitignore).toContain("node_modules/");
+    expect(gitignore).toContain("*.log");
+  });
+
+  test("handles missing template directory gracefully", async () => {
+    const nonExistentTemplate = join(testDir, "nonexistent");
+
+    // Should not throw
+    await expect(
+      copyTemplatesToWorktree({
+        targetDir,
+        projectRoot,
+        templateDir: nonExistentTemplate,
+        logger,
+      })
+    ).resolves.toBeUndefined();
+
+    // Target directory should be created even if templates don't exist
+    const { stat } = await import("node:fs/promises");
+    const stats = await stat(targetDir);
+    expect(stats.isDirectory()).toBe(true);
+  });
+
+  test("preserves existing agent-memory", async () => {
+    // Setup project agent-memory
+    await mkdir(join(projectRoot, ".claude", "agent-memory", "explorer"), { recursive: true });
+    await writeFile(
+      join(projectRoot, ".claude", "agent-memory", "explorer", "MEMORY.md"),
+      "Existing memory"
+    );
+
+    // Setup template agent-memory (should NOT overwrite)
+    await mkdir(join(templateDir, ".claude", "agent-memory", "explorer"), { recursive: true });
+    await writeFile(
+      join(templateDir, ".claude", "agent-memory", "explorer", "MEMORY.md"),
+      "Template memory"
+    );
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    const memory = await Bun.file(
+      join(targetDir, ".claude", "agent-memory", "explorer", "MEMORY.md")
+    ).text();
+    expect(memory).toBe("Existing memory");
+  });
+});
+
+describe("resolveTemplateDir", () => {
+  test("returns local template dir when it exists", () => {
+    // This test assumes the actual project has templates/
+    const result = resolveTemplateDir(process.cwd());
+    expect(result).toBeDefined();
+    expect(result).toContain("templates");
+  });
+
+  test("falls back to package templates when local not found", () => {
+    const result = resolveTemplateDir("/nonexistent");
+    // Should resolve to {packageRoot}/templates, not one level above
+    expect(result).toContain("templates");
+    expect(result).not.toContain("sandbox/templates");
+  });
+});

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

@@ -100,8 +100,35 @@ describe("cleanupOrphanedFromPreviousRuns", () => {
 
     const result = await cleanupOrphanedFromPreviousRuns(worktreeManager, logger);
 
-    // First worktree fails, second succeeds
-    expect(result.removedWorktrees).toBe(1);
+    // First worktree fails git remove but succeeds via fallback (force=true)
+    // Second worktree succeeds normally
+    expect(result.removedWorktrees).toBe(2);
     expect(result.deletedBranches).toBe(2);
   });
+
+  test("preserves parent worktrees (path matches /parent-xxx)", async () => {
+    mockGitOps.gitExec = mock(async (args: string[]) => {
+      if (args[0] === "worktree" && args[1] === "list") {
+        return {
+          stdout: [
+            "worktree /repo", "HEAD abc", "branch refs/heads/main", "",
+            "worktree /repo/.aad/worktrees/task-001", "HEAD def", "branch refs/heads/aad/r/task-001", "",
+            "worktree /repo/.aad/worktrees/parent-run-001", "HEAD ghi", "branch refs/heads/feat/run-001/parent", "",
+          ].join("\n"),
+          stderr: "", exitCode: 0,
+        };
+      }
+      if (args[0] === "branch" && args[1] === "--list") {
+        if (args[2] === "aad/*") return { stdout: "  aad/r/task-001\n", stderr: "", exitCode: 0 };
+        if (args[2] === "feat/*") return { stdout: "  feat/run-001/parent\n", stderr: "", exitCode: 0 };
+        return { stdout: "", stderr: "", exitCode: 0 };
+      }
+      return { stdout: "", stderr: "", exitCode: 0 };
+    });
+
+    const result = await cleanupOrphanedFromPreviousRuns(worktreeManager, logger);
+
+    expect(result.removedWorktrees).toBe(1); // task-001 のみ
+    expect(result.preservedBranches).toBe(1); // feat/run-001/parent
+  });
 });

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

@@ -145,9 +145,24 @@ describe("WorktreeManager", () => {
       await expect(worktreeManager.removeWorktree(worktreePath)).resolves.toBeUndefined();
     });
 
-    test("attempts fallback cleanup on failure", async () => {
+    test("does not attempt fallback cleanup on failure without force", async () => {
       const worktreePath = "/test/worktrees/task-004";
 
+      mockGitOps.gitExec = mock(async () => {
+        throw new Error("git worktree remove failed");
+      });
+
+      await expect(worktreeManager.removeWorktree(worktreePath, false)).rejects.toThrow(
+        GitWorkspaceError
+      );
+
+      // Should NOT call fallback rm when force=false
+      expect(mockFsOps.rm).not.toHaveBeenCalled();
+    });
+
+    test("attempts fallback cleanup on failure with force", async () => {
+      const worktreePath = "/test/worktrees/task-005";
+
       let callCount = 0;
       mockGitOps.gitExec = mock(async () => {
         callCount++;
@@ -157,9 +172,8 @@ describe("WorktreeManager", () => {
         return { stdout: "", stderr: "", exitCode: 0 };
       });
 
-      await expect(worktreeManager.removeWorktree(worktreePath)).rejects.toThrow(
-        GitWorkspaceError
-      );
+      // Should succeed via fallback
+      await expect(worktreeManager.removeWorktree(worktreePath, true)).resolves.toBeUndefined();
 
       expect(mockFsOps.rm).toHaveBeenCalledWith(worktreePath, { recursive: true, force: true });
       expect(mockGitOps.gitExec).toHaveBeenCalledWith(
@@ -167,6 +181,22 @@ describe("WorktreeManager", () => {
         expect.objectContaining({ cwd: repoRoot })
       );
     });
+
+    test("throws if fallback also fails with force", async () => {
+      const worktreePath = "/test/worktrees/task-006";
+
+      mockGitOps.gitExec = mock(async () => {
+        throw new Error("git worktree remove failed");
+      });
+
+      mockFsOps.rm = mock(async () => {
+        throw new Error("rm failed");
+      });
+
+      await expect(worktreeManager.removeWorktree(worktreePath, true)).rejects.toThrow(
+        GitWorkspaceError
+      );
+    });
   });
 
   describe("listWorktrees", () => {
@@ -217,6 +247,36 @@ HEAD 789ghi
 
       expect(worktrees).toEqual([]);
     });
+
+    test("parses worktree list without trailing newline", 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`;
+
+      mockGitOps.gitExec = mock(async () => ({
+        stdout: porcelainOutput,
+        stderr: "",
+        exitCode: 0
+      }));
+
+      const worktrees = await worktreeManager.listWorktrees();
+
+      expect(worktrees).toHaveLength(2);
+      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",
+      });
+    });
   });
 
   describe("verifyWorktree", () => {

package/src/modules/git-workspace/branch-manager.ts

@@ -9,6 +9,11 @@ export interface BranchManagerOptions {
   gitOps?: GitOps;
 }
 
+export interface CleanupBranchOptions {
+  force?: boolean;
+  excludePatterns?: RegExp[];
+}
+
 /**
  * Manage git branches for parallel task execution
  */
@@ -136,7 +141,15 @@ export class BranchManager {
   /**
    * Cleanup orphaned AAD branches (branches without worktrees)
    */
-  async cleanupOrphanBranches(runId?: RunId, force = false): Promise<string[]> {
+  async cleanupOrphanBranches(
+    runId?: RunId,
+    forceOrOptions?: boolean | CleanupBranchOptions,
+  ): Promise<string[]> {
+    // Support both legacy boolean signature and new options object
+    const options: CleanupBranchOptions = typeof forceOrOptions === "boolean"
+      ? { force: forceOrOptions, excludePatterns: [/\/parent$/] }
+      : { force: forceOrOptions?.force ?? false, excludePatterns: forceOrOptions?.excludePatterns ?? [/\/parent$/] };
+
     // Support aad/*, conventional commit prefixes (feat/*, fix/*, etc.), and legacy aad-* patterns
     const conventionalPrefixes = ["aad", "feat", "fix", "docs", "style", "refactor", "perf", "test", "chore"];
     const patterns = runId
@@ -149,7 +162,7 @@ export class BranchManager {
           "aad-*",
         ];
 
-    this.logger?.info({ patterns, force }, "Cleaning up orphan branches");
+    this.logger?.info({ patterns, force: options.force, excludePatterns: options.excludePatterns }, "Cleaning up orphan branches");
 
     const deleted: string[] = [];
 
@@ -157,9 +170,17 @@ export class BranchManager {
       const branches = await this.listBranches(pattern);
 
       for (const branch of branches) {
+        // Check if branch matches any exclude pattern
+        const excludePatterns = options.excludePatterns ?? [/\/parent$/];
+        const isExcluded = excludePatterns.some((pattern) => pattern.test(branch));
+        if (isExcluded) {
+          this.logger?.info({ branch }, "Preserving parent branch (contains commit history)");
+          continue;
+        }
+
         try {
           // Delete branch (force if requested)
-          await this.deleteBranch(branch, force);
+          await this.deleteBranch(branch, options.force);
           deleted.push(branch);
           this.logger?.info({ branch }, "Deleted orphan branch");
         } catch (error) {