fix(git): hide worktree branches in picker

Author: pallyoung

packages/core/src/domain/types.ts

@@ -124,6 +124,7 @@ export interface GitBranch {
   isRemote: boolean; // Whether it's a remote branch
   isCurrent: boolean; // Whether it's the current branch
   remote?: string; // Remote name (e.g., "origin")
+  linkedWorktreePath?: string; // Path of another worktree using this branch, if any
 }
 
 export interface WorktreeInfo {

packages/server/src/__tests__/git/cli.test.ts

@@ -14,6 +14,7 @@ import {
   getGitHistory,
   getGitStatus,
   runGit,
+  runGitCheckout,
   runGitFetch,
   runGitPull,
   runGitPush,
@@ -609,7 +610,7 @@ describe("runGitListBranches", () => {
     await rm(testDir, { recursive: true });
   });
 
-  it("strips linked worktree markers from local branch names", async () => {
+  it("omits local branches that are checked out in another worktree", async () => {
     await writeFile(join(testDir, "README.md"), "test");
     await execFileAsync("git", ["add", "."], { cwd: testDir });
     await execFileAsync("git", ["commit", "-m", "initial"], { cwd: testDir });
@@ -624,11 +625,11 @@ describe("runGitListBranches", () => {
     const result = await runGitListBranches(testDir);
 
     expect(result.current).toBe(defaultBranch);
-    expect(result.branches).toContainEqual({
-      name: "feature/worktree-branch",
-      isRemote: false,
-      isCurrent: false,
-    });
+    expect(result.branches).not.toContainEqual(
+      expect.objectContaining({
+        name: "feature/worktree-branch",
+      })
+    );
     expect(result.branches).not.toContainEqual(
       expect.objectContaining({
         name: expect.stringMatching(/^\+\s/),
@@ -716,6 +717,42 @@ describe("getGitStatus", () => {
   });
 });
 
+describe("runGitCheckout", () => {
+  it("switches to an existing local branch when selecting a remote branch with the same short name", async () => {
+    const testDir = await mkdtemp(join(tmpdir(), "git-checkout-remote-existing-local-"));
+    const remoteDir = await mkdtemp(join(tmpdir(), "git-checkout-remote-existing-local-remote-"));
+
+    await execFileAsync("git", ["init"], { cwd: testDir });
+    await execFileAsync("git", ["config", "user.name", "Test"], { cwd: testDir });
+    await execFileAsync("git", ["config", "user.email", "test@example.com"], { cwd: testDir });
+    await writeFile(join(testDir, "README.md"), "test");
+    await execFileAsync("git", ["add", "."], { cwd: testDir });
+    await execFileAsync("git", ["commit", "-m", "initial"], { cwd: testDir });
+
+    await execFileAsync("git", ["init", "--bare"], { cwd: remoteDir });
+    await execFileAsync("git", ["remote", "add", "origin", remoteDir], { cwd: testDir });
+
+    await execFileAsync("git", ["checkout", "-b", "feature/login"], { cwd: testDir });
+    await execFileAsync("git", ["push", "-u", "origin", "feature/login"], { cwd: testDir });
+    await execFileAsync("git", ["checkout", "master"], { cwd: testDir });
+
+    const result = await runGitCheckout(testDir, "origin/feature/login");
+
+    expect(result).toMatchObject({
+      success: true,
+      branch: "feature/login",
+    });
+    await expect(
+      execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: testDir })
+    ).resolves.toMatchObject({
+      stdout: "feature/login\n",
+    });
+
+    await rm(testDir, { recursive: true });
+    await rm(remoteDir, { recursive: true });
+  });
+});
+
 describe("getGitHistory", () => {
   it("returns recent commits in reverse chronological order with author and timestamp", async () => {
     const testDir = await mkdtemp(join(tmpdir(), "git-history-"));

packages/server/src/git/cli.ts

@@ -568,7 +568,15 @@ export async function runGitCheckout(
   if (isRemoteRef && !options?.createBranch) {
     const remoteSeparatorIndex = ref.indexOf("/");
     const branchName = remoteSeparatorIndex >= 0 ? ref.slice(remoteSeparatorIndex + 1) : ref;
-    args.push("-b", branchName, ref);
+
+    try {
+      await runGit(cwd, ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`]);
+      const { stdout, stderr } = await runGit(cwd, ["checkout", branchName]);
+      const message = stdout || stderr || `Checkout to ${branchName} completed`;
+      return { success: true, message, branch: branchName };
+    } catch {
+      args.push("-b", branchName, ref);
+    }
 
     try {
       const { stdout, stderr } = await runGit(cwd, args);
@@ -644,12 +652,29 @@ export async function runGitListBranches(cwd: string): Promise<{
 }> {
   // Get local branches
   const { stdout: localOutput } = await runGit(cwd, ["branch", "--list"]);
+  const { stdout: localVerboseOutput } = await runGit(cwd, ["branch", "--list", "-vv"]);
 
   // Get remote branches
   const { stdout: remoteOutput } = await runGit(cwd, ["branch", "-r"]);
 
   const branches: GitBranch[] = [];
   let current = "";
+  const linkedWorktreePathsByBranch = new Map<string, string>();
+
+  const localVerboseLines = localVerboseOutput.split("\n").filter((line) => line.trim());
+  for (const line of localVerboseLines) {
+    const normalizedLine = line.replace(/^[*+ ]\s+/, "");
+    const branchMatch = normalizedLine.match(/^([^\s]+)\s+/);
+    const worktreeMatch = line.match(/\((.+?)\)\s/);
+    if (!branchMatch?.[1] || !worktreeMatch?.[1]) {
+      continue;
+    }
+
+    const worktreePath = worktreeMatch[1];
+    if (worktreePath.startsWith("/") || worktreePath.startsWith("~")) {
+      linkedWorktreePathsByBranch.set(branchMatch[1], worktreePath);
+    }
+  }
 
   // Parse local branches
   const localLines = localOutput.split("\n").filter((line) => line.trim());
@@ -665,10 +690,15 @@ export async function runGitListBranches(cwd: string): Promise<{
       continue; // Don't add to branches array
     }
 
+    if (linkedWorktreePathsByBranch.has(name) && !isCurrent) {
+      continue;
+    }
+
     branches.push({
       name,
       isRemote: false,
       isCurrent,
+      linkedWorktreePath: linkedWorktreePathsByBranch.get(name),
     });
     if (isCurrent) {
       current = name;

packages/web/src/features/workspace/actions/use-git-actions.ts

@@ -930,6 +930,7 @@ export function useBranchQuickPickActions() {
   const quickPickState = useAtomValue(branchQuickPickAtom);
   const setQuickPick = useSetAtom(branchQuickPickAtom);
   const dispatch = useAtomValue(dispatchCommandAtom);
+  const pushToast = useSetAtom(pushToastAtom);
   const workspaceId = quickPickState.workspaceId;
   const branchList = useAtomValue(gitBranchListAtomFamily(workspaceId ?? ""));
   const setBranchList = useSetAtom(gitBranchListAtomFamily(workspaceId ?? ""));
@@ -1011,12 +1012,19 @@ export function useBranchQuickPickActions() {
 
   const filteredBranches = useMemo(
     () =>
-      branchList.branches.filter((branch) =>
-        branch.name.toLowerCase().includes(inputValue.toLowerCase())
+      branchList.branches.filter(
+        (branch) =>
+          (branch.isCurrent || !branch.linkedWorktreePath) &&
+          branch.name.toLowerCase().includes(inputValue.toLowerCase())
       ),
     [branchList.branches, inputValue]
   );
 
+  const isBranchSelectable = useCallback(
+    (branch: GitBranch) => branch.isCurrent || !branch.linkedWorktreePath,
+    []
+  );
+
   const exactMatch = filteredBranches.find(
     (branch) => branch.name.toLowerCase() === inputValue.toLowerCase()
   );
@@ -1109,14 +1117,20 @@ export function useBranchQuickPickActions() {
       });
 
       if (!result.ok || !result.data?.success) {
-        console.error("Failed to checkout branch:", result.error?.message ?? result.data?.message);
+        const errorMessage = result.error?.message ?? result.data?.message;
+        console.error("Failed to checkout branch:", errorMessage);
+        pushToast({
+          kind: "error",
+          title: t("git.quick_pick.checkout_failed_title"),
+          body: errorMessage || t("git.quick_pick.checkout_failed_body", { name: branchName }),
+        });
         return;
       }
 
       await refreshBranchState();
       handleClose();
     },
-    [dispatch, handleClose, refreshBranchState, workspaceId]
+    [dispatch, handleClose, pushToast, refreshBranchState, t, workspaceId]
   );
 
   const handleBranchCreate = useCallback(
@@ -1132,14 +1146,20 @@ export function useBranchQuickPickActions() {
       });
 
       if (!result.ok || !result.data?.success) {
-        console.error("Failed to create branch:", result.error?.message ?? result.data?.message);
+        const errorMessage = result.error?.message ?? result.data?.message;
+        console.error("Failed to create branch:", errorMessage);
+        pushToast({
+          kind: "error",
+          title: t("git.quick_pick.create_failed_title"),
+          body: errorMessage || t("git.quick_pick.create_failed_body", { name: branchName }),
+        });
         return;
       }
 
       await refreshBranchState();
       handleClose();
     },
-    [dispatch, handleClose, refreshBranchState, workspaceId]
+    [dispatch, handleClose, pushToast, refreshBranchState, t, workspaceId]
   );
 
   return {
@@ -1151,6 +1171,7 @@ export function useBranchQuickPickActions() {
     handleClose,
     handleRequestBranchCreate,
     inputValue,
+    isBranchSelectable,
     pendingCreateBranchName,
     quickPickState,
     selectedIndex,

packages/web/src/features/workspace/views/shared/branch-quick-pick.test.tsx

@@ -5,6 +5,7 @@ import { createStore, Provider, useSetAtom } from "jotai";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { localeAtom } from "../../../../atoms/app-ui";
 import { wsClientAtom } from "../../../../atoms/connection";
+import { toastsAtom } from "../../../notifications/atoms";
 import { branchQuickPickAtom, gitBranchListAtomFamily } from "../../atoms";
 import { BranchQuickPick, DesktopBranchQuickPickPopover } from "./branch-quick-pick";
 
@@ -198,6 +199,28 @@ describe("BranchQuickPick", () => {
     expect(screen.getByText("Current Branch")).toBeInTheDocument();
   });
 
+  it("hides branches that are already checked out in another worktree on mobile", () => {
+    viewportMocks.viewport = "mobile";
+    store.set(gitBranchListAtomFamily("ws-test"), {
+      current: "develop",
+      branches: [
+        {
+          name: "chore/e2e-specs-reorg",
+          isCurrent: false,
+          isRemote: false,
+          linkedWorktreePath: "/tmp/e2e-specs-reorg",
+        },
+        { name: "develop", isCurrent: true, isRemote: false },
+      ],
+      loading: false,
+    });
+
+    renderQuickPick();
+
+    expect(screen.queryByRole("button", { name: "chore/e2e-specs-reorg" })).not.toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "develop" })).toBeInTheDocument();
+  });
+
   it("does not keep the current branch selected when mobile focus moves to create branch", async () => {
     viewportMocks.viewport = "mobile";
     store.set(branchQuickPickAtom, {
@@ -307,6 +330,50 @@ describe("BranchQuickPick", () => {
     });
   });
 
+  it("shows an error toast and keeps the picker open when checkout fails", async () => {
+    viewportMocks.viewport = "mobile";
+    sendCommandMock.mockImplementation(async (op: string) => {
+      if (op === "git.checkout") {
+        return {
+          success: false,
+          message: "Branch is already used by another worktree",
+        };
+      }
+
+      if (op === "git.branches") {
+        return {
+          current: "main",
+          branches: [
+            { name: "main", isCurrent: true, isRemote: false },
+            { name: "feature/auth", isCurrent: false, isRemote: false },
+          ],
+        };
+      }
+
+      if (op === "git.status") {
+        return gitStatus;
+      }
+
+      return undefined;
+    });
+
+    renderQuickPick();
+
+    fireEvent.click(screen.getByRole("button", { name: "feature/auth" }));
+
+    await waitFor(() => {
+      expect(store.get(toastsAtom)).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            kind: "error",
+            body: "Branch is already used by another worktree",
+          }),
+        ])
+      );
+    });
+    expect(store.get(branchQuickPickAtom).visible).toBe(true);
+  });
+
   it("requires confirmation before creating a new branch on Enter", async () => {
     renderQuickPick();