diff --git a/apps/array/src/main/preload.ts b/apps/array/src/main/preload.ts
index d9abff99..6aaabe0f 100644
--- a/apps/array/src/main/preload.ts
+++ b/apps/array/src/main/preload.ts
@@ -282,6 +282,12 @@ contextBridge.exposeInMainWorld("electronAPI", {
   }> => ipcRenderer.invoke("get-diff-stats", repoPath),
   getCurrentBranch: (repoPath: string): Promise<string | undefined> =>
     ipcRenderer.invoke("get-current-branch", repoPath),
+  getDefaultBranch: (repoPath: string): Promise<string> =>
+    ipcRenderer.invoke("get-default-branch", repoPath),
+  getAllBranches: (repoPath: string): Promise<string[]> =>
+    ipcRenderer.invoke("get-all-branches", repoPath),
+  createBranch: (repoPath: string, branchName: string): Promise<void> =>
+    ipcRenderer.invoke("create-branch", repoPath, branchName),
   discardFileChanges: (
     repoPath: string,
     filePath: string,
diff --git a/apps/array/src/main/services/git.ts b/apps/array/src/main/services/git.ts
index 22dc5fb5..5c05c441 100644
--- a/apps/array/src/main/services/git.ts
+++ b/apps/array/src/main/services/git.ts
@@ -153,6 +153,36 @@ export const getDefaultBranch = async (
   }
 };
 
+export const getAllBranches = async (
+  directoryPath: string,
+): Promise<string[]> => {
+  try {
+    const { stdout } = await execAsync(
+      'git branch --list --format="%(refname:short)"',
+      {
+        cwd: directoryPath,
+      },
+    );
+    return stdout
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((branch) => branch.trim())
+      .filter((branch) => !branch.startsWith("array/"));
+  } catch {
+    return [];
+  }
+};
+
+export const createBranch = async (
+  directoryPath: string,
+  branchName: string,
+): Promise<void> => {
+  await execAsync(`git checkout -b "${branchName}"`, {
+    cwd: directoryPath,
+  });
+};
+
 const getChangedFiles = async (directoryPath: string): Promise<Set<string>> => {
   const changedFiles = new Set<string>();
 
@@ -785,6 +815,37 @@ export function registerGitIpc(
     },
   );
 
+  ipcMain.handle(
+    "get-default-branch",
+    async (
+      _event: IpcMainInvokeEvent,
+      directoryPath: string,
+    ): Promise<string> => {
+      return getDefaultBranch(directoryPath);
+    },
+  );
+
+  ipcMain.handle(
+    "get-all-branches",
+    async (
+      _event: IpcMainInvokeEvent,
+      directoryPath: string,
+    ): Promise<string[]> => {
+      return getAllBranches(directoryPath);
+    },
+  );
+
+  ipcMain.handle(
+    "create-branch",
+    async (
+      _event: IpcMainInvokeEvent,
+      directoryPath: string,
+      branchName: string,
+    ): Promise<void> => {
+      return createBranch(directoryPath, branchName);
+    },
+  );
+
   ipcMain.handle(
     "discard-file-changes",
     async (
diff --git a/apps/array/src/main/services/workspace/workspaceService.ts b/apps/array/src/main/services/workspace/workspaceService.ts
index aec98269..9977cbe4 100644
--- a/apps/array/src/main/services/workspace/workspaceService.ts
+++ b/apps/array/src/main/services/workspace/workspaceService.ts
@@ -84,7 +84,8 @@ export class WorkspaceService {
   async createWorkspace(
     options: CreateWorkspaceOptions,
   ): Promise<WorkspaceInfo> {
-    const { taskId, mainRepoPath, folderId, folderPath, mode } = options;
+    const { taskId, mainRepoPath, folderId, folderPath, mode, branch } =
+      options;
     log.info(
       `Creating workspace for task ${taskId} in ${mainRepoPath} (mode: ${mode})`,
     );
@@ -117,6 +118,25 @@ export class WorkspaceService {
 
     // Root mode: skip worktree creation entirely
     if (mode === "root") {
+      // try to create the branch, if it already exists just switch to it
+      if (branch) {
+        try {
+          log.info(`Creating/switching to branch ${branch} for task ${taskId}`);
+          try {
+            await execAsync(`git checkout -b "${branch}"`, { cwd: folderPath });
+            log.info(`Created and switched to new branch ${branch}`);
+          } catch (_error) {
+            await execAsync(`git checkout "${branch}"`, { cwd: folderPath });
+            log.info(`Switched to existing branch ${branch}`);
+          }
+        } catch (error) {
+          log.error(`Failed to create/switch to branch ${branch}:`, error);
+          throw new Error(
+            `Failed to create/switch to branch ${branch}: ${String(error)}`,
+          );
+        }
+      }
+
       // Save task association without worktree
       const associations = getTaskAssociations();
       const existingIndex = associations.findIndex((a) => a.taskId === taskId);
@@ -219,7 +239,9 @@ export class WorkspaceService {
     let worktree: WorktreeInfo;
 
     try {
-      worktree = await worktreeManager.createWorktree();
+      worktree = await worktreeManager.createWorktree({
+        baseBranch: branch ?? undefined,
+      });
       log.info(
         `Created worktree: ${worktree.worktreeName} at ${worktree.worktreePath}`,
       );
diff --git a/apps/array/src/renderer/features/folder-picker/components/FolderPicker.tsx b/apps/array/src/renderer/features/folder-picker/components/FolderPicker.tsx
index 4e7d4366..53579373 100644
--- a/apps/array/src/renderer/features/folder-picker/components/FolderPicker.tsx
+++ b/apps/array/src/renderer/features/folder-picker/components/FolderPicker.tsx
@@ -61,12 +61,7 @@ export function FolderPicker({
         onClick={handleOpenFilePicker}
       >
         <Flex justify="between" align="center" gap="2" width="100%">
-          <Flex
-            align="center"
-            gap="2"
-            width="250px"
-            style={{ minWidth: 0, flex: 1 }}
-          >
+          <Flex align="center" gap="2">
             <FolderIcon size={16} weight="regular" style={{ flexShrink: 0 }} />
             <Text
               size={size}
@@ -74,6 +69,7 @@ export function FolderPicker({
                 overflow: "hidden",
                 textOverflow: "ellipsis",
                 whiteSpace: "nowrap",
+                maxWidth: "120px",
               }}
               truncate
             >
@@ -90,13 +86,8 @@ export function FolderPicker({
     <DropdownMenu.Root>
       <DropdownMenu.Trigger>
         <Button color="gray" variant="outline" size={size}>
-          <Flex justify="between" align="center" gap="2" width="100%">
-            <Flex
-              align="center"
-              gap="2"
-              width="250px"
-              style={{ minWidth: 0, flex: 1 }}
-            >
+          <Flex justify="between" align="center" gap="2">
+            <Flex align="center" gap="2" style={{ minWidth: 0 }}>
               <FolderIcon
                 size={16}
                 weight="regular"
diff --git a/apps/array/src/renderer/features/task-detail/components/BranchSelect.tsx b/apps/array/src/renderer/features/task-detail/components/BranchSelect.tsx
new file mode 100644
index 00000000..235cc00c
--- /dev/null
+++ b/apps/array/src/renderer/features/task-detail/components/BranchSelect.tsx
@@ -0,0 +1,263 @@
+import { GitBranchIcon, PlusIcon } from "@phosphor-icons/react";
+import { ChevronDownIcon } from "@radix-ui/react-icons";
+import { Button, DropdownMenu, Flex, Text, TextField } from "@radix-ui/themes";
+import type { Responsive } from "@radix-ui/themes/dist/esm/props/prop-def.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+const MAX_DISPLAYED_BRANCHES = 20;
+
+interface BranchSelectProps {
+  value: string | null; // null means use default branch
+  onChange: (branch: string | null) => void;
+  directoryPath: string;
+  size?: Responsive<"1" | "2">;
+}
+
+export function BranchSelect({
+  value,
+  onChange,
+  directoryPath,
+  size = "1",
+}: BranchSelectProps) {
+  const [branches, setBranches] = useState<string[]>([]);
+  const [defaultBranch, setDefaultBranch] = useState<string>("");
+  const [isCreatingNew, setIsCreatingNew] = useState(false);
+  const [newBranchName, setNewBranchName] = useState("");
+  const [searchQuery, setSearchQuery] = useState("");
+  const [isLoading, setIsLoading] = useState(true);
+  const hasSetInitialValue = useRef(false);
+
+  useEffect(() => {
+    if (!directoryPath) {
+      setIsLoading(false);
+      setBranches([]);
+      setDefaultBranch("");
+      return;
+    }
+
+    let cancelled = false;
+    hasSetInitialValue.current = false;
+
+    const load = async () => {
+      setIsLoading(true);
+      try {
+        const [allBranches, detectedDefault] = await Promise.all([
+          window.electronAPI.getAllBranches(directoryPath),
+          window.electronAPI.getDefaultBranch(directoryPath),
+        ]);
+
+        if (cancelled) return;
+
+        setBranches(allBranches);
+        setDefaultBranch(detectedDefault);
+      } catch (_error) {
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    };
+
+    load();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [directoryPath]);
+
+  useEffect(() => {
+    if (!hasSetInitialValue.current && value === null && defaultBranch) {
+      hasSetInitialValue.current = true;
+      onChange(defaultBranch);
+    }
+  }, [defaultBranch, value, onChange]);
+
+  const handleOpenChange = useCallback(
+    async (open: boolean) => {
+      if (open) {
+        setSearchQuery("");
+        if (directoryPath) {
+          try {
+            const [allBranches, detectedDefault] = await Promise.all([
+              window.electronAPI.getAllBranches(directoryPath),
+              window.electronAPI.getDefaultBranch(directoryPath),
+            ]);
+            setBranches(allBranches);
+            setDefaultBranch(detectedDefault);
+          } catch (_error) {}
+        }
+      }
+    },
+    [directoryPath],
+  );
+
+  const handleCreateNew = () => {
+    setIsCreatingNew(true);
+    setNewBranchName(searchQuery);
+  };
+
+  const handleCancelCreate = () => {
+    setIsCreatingNew(false);
+    setNewBranchName("");
+  };
+
+  const handleConfirmCreate = () => {
+    if (newBranchName.trim()) {
+      onChange(newBranchName.trim());
+      setIsCreatingNew(false);
+      setNewBranchName("");
+    }
+  };
+
+  // filter branches based on search query
+  const filteredBranches = useMemo(() => {
+    let result = branches;
+    if (searchQuery.trim()) {
+      const query = searchQuery.toLowerCase();
+      result = branches.filter((branch) =>
+        branch.toLowerCase().includes(query),
+      );
+    }
+    return result.slice(0, MAX_DISPLAYED_BRANCHES);
+  }, [branches, searchQuery]);
+
+  const hasMoreBranches =
+    branches.length > MAX_DISPLAYED_BRANCHES && !searchQuery;
+
+  const displayValue = value || defaultBranch || "Select branch";
+
+  if (isCreatingNew) {
+    return (
+      <Flex gap="2" align="center">
+        <TextField.Root
+          size={size}
+          placeholder="New branch name..."
+          value={newBranchName}
+          onChange={(e) => setNewBranchName(e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") {
+              handleConfirmCreate();
+            } else if (e.key === "Escape") {
+              handleCancelCreate();
+            }
+          }}
+          autoFocus
+          style={{ flex: 1, minWidth: 0 }}
+        />
+        <Button
+          size={size}
+          variant="soft"
+          onClick={handleConfirmCreate}
+          disabled={!newBranchName.trim()}
+        >
+          Create
+        </Button>
+        <Button size={size} variant="ghost" onClick={handleCancelCreate}>
+          Cancel
+        </Button>
+      </Flex>
+    );
+  }
+
+  return (
+    <DropdownMenu.Root onOpenChange={handleOpenChange}>
+      <DropdownMenu.Trigger>
+        <Button color="gray" variant="outline" size={size} disabled={isLoading}>
+          <Flex justify="between" align="center" gap="2">
+            <Flex align="center" gap="2" style={{ minWidth: 0 }}>
+              <GitBranchIcon size={16} weight="regular" />
+              <Text
+                size={size}
+                style={{
+                  overflow: "hidden",
+                  textOverflow: "ellipsis",
+                  whiteSpace: "nowrap",
+                }}
+              >
+                {displayValue}
+              </Text>
+            </Flex>
+            <ChevronDownIcon style={{ flexShrink: 0 }} />
+          </Flex>
+        </Button>
+      </DropdownMenu.Trigger>
+
+      <DropdownMenu.Content
+        align="start"
+        style={{ minWidth: "200px", maxHeight: "300px", overflowY: "auto" }}
+        size={size}
+      >
+        <div style={{ padding: "4px 8px" }}>
+          <TextField.Root
+            size="1"
+            placeholder="Filter branches..."
+            value={searchQuery}
+            onChange={(e) => setSearchQuery(e.target.value)}
+            onClick={(e) => e.stopPropagation()}
+            onKeyDown={(e) => e.stopPropagation()}
+          />
+        </div>
+        <DropdownMenu.Separator />
+
+        {defaultBranch && filteredBranches.includes(defaultBranch) && (
+          <DropdownMenu.Item onSelect={() => onChange(defaultBranch)}>
+            <Flex align="center" gap="2">
+              <GitBranchIcon size={12} weight="bold" />
+              <Text size={size} weight="medium">
+                {defaultBranch}
+              </Text>
+            </Flex>
+          </DropdownMenu.Item>
+        )}
+
+        {filteredBranches.filter((branch) => branch !== defaultBranch).length >
+          0 && (
+          <>
+            {defaultBranch && filteredBranches.includes(defaultBranch) && (
+              <DropdownMenu.Separator />
+            )}
+            {filteredBranches
+              .filter((branch) => branch !== defaultBranch)
+              .map((branch) => (
+                <DropdownMenu.Item
+                  key={branch}
+                  onSelect={() => onChange(branch)}
+                >
+                  <Flex align="center" gap="2">
+                    <GitBranchIcon size={12} />
+                    <Text size={size}>{branch}</Text>
+                  </Flex>
+                </DropdownMenu.Item>
+              ))}
+          </>
+        )}
+
+        {hasMoreBranches && (
+          <DropdownMenu.Label>
+            <Text size="1" color="gray">
+              Type to filter {branches.length - MAX_DISPLAYED_BRANCHES} more...
+            </Text>
+          </DropdownMenu.Label>
+        )}
+
+        {filteredBranches.length === 0 && searchQuery && (
+          <DropdownMenu.Label>
+            <Text size="1" color="gray">
+              No branches match "{searchQuery}"
+            </Text>
+          </DropdownMenu.Label>
+        )}
+
+        <DropdownMenu.Separator />
+        <DropdownMenu.Item onSelect={handleCreateNew}>
+          <Flex align="center" gap="2">
+            <PlusIcon size={12} />
+            <Text size={size}>
+              {searchQuery ? `Create "${searchQuery}"` : "Create new branch..."}
+            </Text>
+          </Flex>
+        </DropdownMenu.Item>
+      </DropdownMenu.Content>
+    </DropdownMenu.Root>
+  );
+}
diff --git a/apps/array/src/renderer/features/task-detail/components/TaskInput.tsx b/apps/array/src/renderer/features/task-detail/components/TaskInput.tsx
index d0d5fa21..1588e382 100644
--- a/apps/array/src/renderer/features/task-detail/components/TaskInput.tsx
+++ b/apps/array/src/renderer/features/task-detail/components/TaskInput.tsx
@@ -11,6 +11,7 @@ import { useTaskDirectoryStore } from "@stores/taskDirectoryStore";
 import { useEffect, useState } from "react";
 import { useEditorSetup } from "../hooks/useEditorSetup";
 import { useTaskCreation } from "../hooks/useTaskCreation";
+import { BranchSelect } from "./BranchSelect";
 import { type RunMode, RunModeSelect } from "./RunModeSelect";
 import { SuggestedTasks } from "./SuggestedTasks";
 import { TaskInputEditor } from "./TaskInputEditor";
@@ -38,6 +39,7 @@ export function TaskInput() {
   );
   const [localWorkspaceMode, setLocalWorkspaceMode] =
     useState<LocalWorkspaceMode>(lastUsedLocalWorkspaceMode);
+  const [selectedBranch, setSelectedBranch] = useState<string | null>(null);
 
   const { githubIntegration } = useRepositoryIntegration();
 
@@ -70,6 +72,7 @@ export function TaskInput() {
     selectedRepository,
     githubIntegrationId: githubIntegration?.id,
     workspaceMode: effectiveWorkspaceMode,
+    branch: selectedBranch,
   });
 
   return (
@@ -140,6 +143,13 @@ export function TaskInput() {
           {import.meta.env.DEV && (
             <RunModeSelect value={runMode} onChange={setRunMode} size="1" />
           )}
+          {selectedDirectory && (
+            <BranchSelect
+              value={selectedBranch}
+              onChange={setSelectedBranch}
+              directoryPath={selectedDirectory}
+            />
+          )}
         </Flex>
 
         <TaskInputEditor
diff --git a/apps/array/src/renderer/features/task-detail/hooks/useTaskCreation.ts b/apps/array/src/renderer/features/task-detail/hooks/useTaskCreation.ts
index 818d24ac..47403c2a 100644
--- a/apps/array/src/renderer/features/task-detail/hooks/useTaskCreation.ts
+++ b/apps/array/src/renderer/features/task-detail/hooks/useTaskCreation.ts
@@ -25,6 +25,7 @@ interface UseTaskCreationOptions {
   selectedRepository?: string | null;
   githubIntegrationId?: number;
   workspaceMode: WorkspaceMode;
+  branch?: string | null;
 }
 
 interface UseTaskCreationReturn {
@@ -51,6 +52,7 @@ export function useTaskCreation({
   selectedRepository,
   githubIntegrationId,
   workspaceMode,
+  branch,
 }: UseTaskCreationOptions): UseTaskCreationReturn {
   const { mutate: createTask, invalidateTasks } = useCreateTask();
   const [isSubmitting, setIsSubmitting] = useState(false);
@@ -134,7 +136,12 @@ export function useTaskCreation({
               try {
                 await useWorkspaceStore
                   .getState()
-                  .ensureWorkspace(newTask.id, selectedDirectory, "cloud");
+                  .ensureWorkspace(
+                    newTask.id,
+                    selectedDirectory,
+                    "cloud",
+                    branch,
+                  );
               } catch (error) {
                 log.error("Failed to create cloud workspace:", error);
               }
@@ -166,6 +173,7 @@ export function useTaskCreation({
                     newTask.id,
                     selectedDirectory,
                     workspaceMode,
+                    branch,
                   );
                 agentCwd = workspace.worktreePath ?? workspace.folderPath;
               } catch (error) {
@@ -204,6 +212,7 @@ export function useTaskCreation({
     selectedRepository,
     githubIntegrationId,
     workspaceMode,
+    branch,
     createTask,
     saveRepoPath,
     navigateToTask,
diff --git a/apps/array/src/renderer/features/workspace/stores/workspaceStore.ts b/apps/array/src/renderer/features/workspace/stores/workspaceStore.ts
index e044e5e3..013bef42 100644
--- a/apps/array/src/renderer/features/workspace/stores/workspaceStore.ts
+++ b/apps/array/src/renderer/features/workspace/stores/workspaceStore.ts
@@ -45,6 +45,7 @@ interface WorkspaceState {
     taskId: string,
     repoPath: string,
     mode?: WorkspaceMode,
+    branch?: string | null,
   ) => Promise<Workspace>;
 
   // Operations
@@ -165,6 +166,7 @@ const useWorkspaceStoreBase = create<WorkspaceState>()((set, get) => {
       taskId: string,
       repoPath: string,
       mode: WorkspaceMode = "worktree",
+      branch?: string | null,
     ) => {
       // Return existing workspace if it exists
       const existing = get().workspaces[taskId];
@@ -189,7 +191,7 @@ const useWorkspaceStoreBase = create<WorkspaceState>()((set, get) => {
           worktreePath: null,
           worktreeName: null,
           branchName: null,
-          baseBranch: null,
+          baseBranch: branch ?? null,
           createdAt: new Date().toISOString(),
           terminalSessionIds: [],
           hasStartScripts: false,
@@ -206,6 +208,7 @@ const useWorkspaceStoreBase = create<WorkspaceState>()((set, get) => {
           folderId: folder.id,
           folderPath: repoPath,
           mode: "cloud",
+          branch: branch ?? undefined,
         });
 
         return cloudWorkspace;
@@ -258,6 +261,7 @@ const useWorkspaceStoreBase = create<WorkspaceState>()((set, get) => {
           folderId: folder.id,
           folderPath: repoPath,
           mode,
+          branch: branch ?? undefined,
         });
 
         if (!workspaceInfo) {
diff --git a/apps/array/src/renderer/stores/taskDirectoryStore.ts b/apps/array/src/renderer/stores/taskDirectoryStore.ts
index a97e47ed..77080b40 100644
--- a/apps/array/src/renderer/stores/taskDirectoryStore.ts
+++ b/apps/array/src/renderer/stores/taskDirectoryStore.ts
@@ -10,6 +10,7 @@ interface TaskDirectoryState {
   getTaskDirectory: (taskId: string, repoKey?: string) => string | null;
   setRepoDirectory: (repoKey: string, directory: string) => void;
   clearRepoDirectory: (repoKey: string) => void;
+  validateLastUsedDirectory: () => Promise<void>;
 }
 
 const isValidPath = (path: string): boolean => {
@@ -54,6 +55,17 @@ export const useTaskDirectoryStore = create<TaskDirectoryState>()(
           repoDirectories: omitKey(state.repoDirectories, repoKey),
         }));
       },
+
+      validateLastUsedDirectory: async () => {
+        const { lastUsedDirectory } = get();
+        if (!lastUsedDirectory) return;
+
+        const exists =
+          await window.electronAPI?.validateRepo(lastUsedDirectory);
+        if (!exists) {
+          set({ lastUsedDirectory: null });
+        }
+      },
     }),
     {
       name: "task-directory-mappings",
@@ -84,6 +96,9 @@ export const useTaskDirectoryStore = create<TaskDirectoryState>()(
           state.repoDirectories = cleanedRepoDirs;
           state.lastUsedDirectory = cleanedLastUsed;
         }
+
+        // Validate that lastUsedDirectory still exists on disk
+        state.validateLastUsedDirectory();
       },
     },
   ),
diff --git a/apps/array/src/renderer/types/electron.d.ts b/apps/array/src/renderer/types/electron.d.ts
index 375e60b2..07645224 100644
--- a/apps/array/src/renderer/types/electron.d.ts
+++ b/apps/array/src/renderer/types/electron.d.ts
@@ -195,6 +195,9 @@ declare global {
       linesRemoved: number;
     }>;
     getCurrentBranch: (repoPath: string) => Promise<string | undefined>;
+    getDefaultBranch: (repoPath: string) => Promise<string>;
+    getAllBranches: (repoPath: string) => Promise<string[]>;
+    createBranch: (repoPath: string, branchName: string) => Promise<void>;
     discardFileChanges: (
       repoPath: string,
       filePath: string,
diff --git a/apps/array/src/shared/types.ts b/apps/array/src/shared/types.ts
index 97db44fc..61b81217 100644
--- a/apps/array/src/shared/types.ts
+++ b/apps/array/src/shared/types.ts
@@ -70,6 +70,7 @@ export interface CreateWorkspaceOptions {
   folderId: string;
   folderPath: string;
   mode: WorkspaceMode;
+  branch?: string;
 }
 
 export interface ScriptExecutionResult {
diff --git a/packages/agent/src/worktree-manager.ts b/packages/agent/src/worktree-manager.ts
index d27db5b4..e25e6b20 100644
--- a/packages/agent/src/worktree-manager.ts
+++ b/packages/agent/src/worktree-manager.ts
@@ -628,7 +628,9 @@ export class WorktreeManager {
     }
   }
 
-  async createWorktree(): Promise<WorktreeInfo> {
+  async createWorktree(options?: {
+    baseBranch?: string;
+  }): Promise<WorktreeInfo> {
     // Only modify .git/info/exclude when using in-repo storage
     if (!this.usesExternalPath()) {
       await this.ensureArrayDirIgnored();
@@ -644,7 +646,7 @@ export class WorktreeManager {
     const worktreeName = await this.generateUniqueWorktreeName();
     const worktreePath = this.getWorktreePath(worktreeName);
     const branchName = `array/${worktreeName}`;
-    const baseBranch = await this.getDefaultBranch();
+    const baseBranch = options?.baseBranch ?? (await this.getDefaultBranch());
 
     this.logger.info("Creating worktree", {
       worktreeName,