ccmanager 2.4.1 → 2.5.1

package/dist/components/App.js

@@ -8,8 +8,10 @@ import DeleteWorktree from './DeleteWorktree.js';
 import MergeWorktree from './MergeWorktree.js';
 import Configuration from './Configuration.js';
 import PresetSelector from './PresetSelector.js';
+import RemoteBranchSelector from './RemoteBranchSelector.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { WorktreeService } from '../services/worktreeService.js';
+import { AmbiguousBranchError, } from '../types/index.js';
 import { configurationManager } from '../services/configurationManager.js';
 import { ENV_VARS } from '../constants/env.js';
 import { MULTI_PROJECT_ERRORS } from '../constants/error.js';
@@ -24,6 +26,8 @@ const App = ({ devcontainerConfig, multiProject }) => {
     const [menuKey, setMenuKey] = useState(0); // Force menu refresh
     const [selectedWorktree, setSelectedWorktree] = useState(null); // Store selected worktree for preset selection
     const [selectedProject, setSelectedProject] = useState(null); // Store selected project in multi-project mode
+    // State for remote branch disambiguation
+    const [pendingWorktreeCreation, setPendingWorktreeCreation] = useState(null);
     // Helper function to clear terminal screen
     const clearScreen = () => {
         if (process.stdout.isTTY) {
@@ -70,6 +74,51 @@ const App = ({ devcontainerConfig, multiProject }) => {
             // Don't destroy sessions on unmount - they persist in memory
         };
     }, [sessionManager, multiProject, selectedProject, navigateWithClear]);
+    // Helper function to parse ambiguous branch error and create AmbiguousBranchError
+    const parseAmbiguousBranchError = (errorMessage) => {
+        const pattern = /Ambiguous branch '(.+?)' found in multiple remotes: (.+?)\. Please specify which remote to use\./;
+        const match = errorMessage.match(pattern);
+        if (!match) {
+            return null;
+        }
+        const branchName = match[1];
+        const remoteRefsText = match[2];
+        const remoteRefs = remoteRefsText.split(', ');
+        // Parse remote refs into RemoteBranchMatch objects
+        const matches = remoteRefs.map(fullRef => {
+            const parts = fullRef.split('/');
+            const remote = parts[0];
+            const branch = parts.slice(1).join('/');
+            return {
+                remote,
+                branch,
+                fullRef,
+            };
+        });
+        return new AmbiguousBranchError(branchName, matches);
+    };
+    // Helper function to handle worktree creation results
+    const handleWorktreeCreationResult = (result, creationData) => {
+        if (result.success) {
+            handleReturnToMenu();
+            return;
+        }
+        const errorMessage = result.error || 'Failed to create worktree';
+        const ambiguousError = parseAmbiguousBranchError(errorMessage);
+        if (ambiguousError) {
+            // Handle ambiguous branch error
+            setPendingWorktreeCreation({
+                ...creationData,
+                ambiguousError,
+            });
+            navigateWithClear('remote-branch-selector');
+        }
+        else {
+            // Handle regular error
+            setError(errorMessage);
+            setView('new-worktree');
+        }
+    };
     const handleSelectWorktree = async (worktree) => {
         // Check if this is the new worktree option
         if (worktree.path === '') {
@@ -183,18 +232,43 @@ const App = ({ devcontainerConfig, multiProject }) => {
         setError(null);
         // Create the worktree
         const result = await worktreeService.createWorktree(path, branch, baseBranch, copySessionData, copyClaudeDirectory);
+        // Handle the result using the helper function
+        handleWorktreeCreationResult(result, {
+            path,
+            branch,
+            baseBranch,
+            copySessionData,
+            copyClaudeDirectory,
+        });
+    };
+    const handleCancelNewWorktree = () => {
+        handleReturnToMenu();
+    };
+    const handleRemoteBranchSelected = async (selectedRemoteRef) => {
+        if (!pendingWorktreeCreation)
+            return;
+        // Clear the pending creation data
+        const creationData = pendingWorktreeCreation;
+        setPendingWorktreeCreation(null);
+        // Retry worktree creation with the resolved base branch
+        setView('creating-worktree');
+        setError(null);
+        const result = await worktreeService.createWorktree(creationData.path, creationData.branch, selectedRemoteRef, // Use the selected remote reference
+        creationData.copySessionData, creationData.copyClaudeDirectory);
         if (result.success) {
             // Success - return to menu
             handleReturnToMenu();
         }
         else {
-            // Show error
+            // Show error and return to new worktree form
             setError(result.error || 'Failed to create worktree');
             setView('new-worktree');
         }
     };
-    const handleCancelNewWorktree = () => {
-        handleReturnToMenu();
+    const handleRemoteBranchSelectorCancel = () => {
+        // Clear pending data and return to new worktree form
+        setPendingWorktreeCreation(null);
+        setView('new-worktree');
     };
     const handleDeleteWorktrees = async (worktreePaths, deleteBranch) => {
         setView('deleting-worktree');
@@ -303,6 +377,9 @@ const App = ({ devcontainerConfig, multiProject }) => {
     if (view === 'preset-selector') {
         return (React.createElement(PresetSelector, { onSelect: handlePresetSelected, onCancel: handlePresetSelectorCancel }));
     }
+    if (view === 'remote-branch-selector' && pendingWorktreeCreation) {
+        return (React.createElement(RemoteBranchSelector, { branchName: pendingWorktreeCreation.ambiguousError.branchName, matches: pendingWorktreeCreation.ambiguousError.matches, onSelect: handleRemoteBranchSelected, onCancel: handleRemoteBranchSelectorCancel }));
+    }
     if (view === 'clearing') {
         // Render nothing during the clearing phase to ensure clean transition
         return null;

package/dist/components/NewWorktree.js

@@ -12,7 +12,7 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const isAutoDirectory = worktreeConfig.autoDirectory;
     const limit = 10;
     // Adjust initial step based on auto directory mode
-    const [step, setStep] = useState(isAutoDirectory ? 'branch' : 'path');
+    const [step, setStep] = useState(isAutoDirectory ? 'base-branch' : 'path');
     const [path, setPath] = useState('');
     const [branch, setBranch] = useState('');
     const [baseBranch, setBaseBranch] = useState('');
@@ -59,18 +59,30 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const handlePathSubmit = (value) => {
         if (value.trim()) {
             setPath(value.trim());
-            setStep('branch');
+            setStep('base-branch');
         }
     };
     const handleBranchSubmit = (value) => {
         if (value.trim()) {
             setBranch(value.trim());
-            setStep('base-branch');
+            setStep('copy-settings');
         }
     };
     const handleBaseBranchSelect = (item) => {
         setBaseBranch(item.value);
-        setStep('copy-settings');
+        setStep('branch-strategy');
+    };
+    const handleBranchStrategySelect = (item) => {
+        const useExisting = item.value === 'existing';
+        if (useExisting) {
+            // Use the base branch as the branch name for existing branch
+            setBranch(baseBranch);
+            setStep('copy-settings');
+        }
+        else {
+            // Need to input new branch name
+            setStep('branch');
+        }
     };
     const handleCopySettingsSelect = (item) => {
         setCopyClaudeDirectory(item.value);
@@ -107,31 +119,10 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
                 React.createElement(Text, null, "Enter worktree path (relative to repository root):")),
             React.createElement(Box, null,
                 React.createElement(Text, { color: "cyan" }, '> '),
-                React.createElement(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })))) : step === 'branch' && !isAutoDirectory ? (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, null,
-                    "Enter branch name for worktree at ",
-                    React.createElement(Text, { color: "cyan" }, path),
-                    ":")),
-            React.createElement(Box, null,
-                React.createElement(Text, { color: "cyan" }, '> '),
-                React.createElement(TextInputWrapper, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })))) : step === 'branch' ? (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, null, "Enter branch name (directory will be auto-generated):")),
-            React.createElement(Box, null,
-                React.createElement(Text, { color: "cyan" }, '> '),
-                React.createElement(TextInputWrapper, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })),
-            generatedPath && (React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { dimColor: true },
-                    "Worktree will be created at:",
-                    ' ',
-                    React.createElement(Text, { color: "green" }, generatedPath)))))) : null,
+                React.createElement(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })))) : null,
         step === 'base-branch' && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, null,
-                    "Select base branch for ",
-                    React.createElement(Text, { color: "cyan" }, branch),
-                    ":")),
+                React.createElement(Text, null, "Select base branch for the worktree:")),
             isSearchMode && (React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null, "Search: "),
                 React.createElement(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter branches..." }))),
@@ -143,6 +134,38 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
                 item.label))))) : (React.createElement(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode })),
             !isSearchMode && (React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { dimColor: true }, "Press / to search"))))),
+        step === 'branch-strategy' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Base branch: ",
+                    React.createElement(Text, { color: "cyan" }, baseBranch))),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Choose branch creation strategy:")),
+            React.createElement(SelectInput, { items: [
+                    {
+                        label: 'Create new branch from base branch',
+                        value: 'new',
+                    },
+                    {
+                        label: 'Use existing base branch',
+                        value: 'existing',
+                    },
+                ], onSelect: handleBranchStrategySelect, initialIndex: 0 }))),
+        step === 'branch' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Enter new branch name (will be created from",
+                    ' ',
+                    React.createElement(Text, { color: "cyan" }, baseBranch),
+                    "):")),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: "cyan" }, '> '),
+                React.createElement(TextInputWrapper, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })),
+            isAutoDirectory && generatedPath && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Worktree will be created at:",
+                    ' ',
+                    React.createElement(Text, { color: "green" }, generatedPath)))))),
         step === 'copy-settings' && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null,

package/dist/components/RemoteBranchSelector.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { RemoteBranchMatch } from '../types/index.js';
+interface RemoteBranchSelectorProps {
+    branchName: string;
+    matches: RemoteBranchMatch[];
+    onSelect: (selectedRemoteRef: string) => void;
+    onCancel: () => void;
+}
+declare const RemoteBranchSelector: React.FC<RemoteBranchSelectorProps>;
+export default RemoteBranchSelector;

package/dist/components/RemoteBranchSelector.js

@@ -0,0 +1,47 @@
+import React from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { shortcutManager } from '../services/shortcutManager.js';
+const RemoteBranchSelector = ({ branchName, matches, onSelect, onCancel, }) => {
+    const selectItems = [
+        ...matches.map(match => ({
+            label: `${match.fullRef} (from ${match.remote})`,
+            value: match.fullRef,
+        })),
+        { label: '← Cancel', value: 'cancel' },
+    ];
+    const handleSelectItem = (item) => {
+        if (item.value === 'cancel') {
+            onCancel();
+        }
+        else {
+            onSelect(item.value);
+        }
+    };
+    useInput((input, key) => {
+        if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            onCancel();
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "yellow" }, "\u26A0\uFE0F Ambiguous Branch Reference")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, null,
+                "Branch ",
+                React.createElement(Text, { color: "cyan" },
+                    "'",
+                    branchName,
+                    "'"),
+                " exists in multiple remotes.")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Please select which remote branch you want to use as the base:")),
+        React.createElement(SelectInput, { items: selectItems, onSelect: handleSelectItem, initialIndex: 0 }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Press \u2191\u2193 to navigate, Enter to select,",
+                ' ',
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to cancel"))));
+};
+export default RemoteBranchSelector;

package/dist/components/RemoteBranchSelector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/RemoteBranchSelector.test.js

@@ -0,0 +1,143 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import RemoteBranchSelector from './RemoteBranchSelector.js';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+// Mock ink to avoid stdin issues
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useInput: vi.fn(),
+    };
+});
+// Mock SelectInput to simulate user interactions
+vi.mock('ink-select-input', async () => {
+    const React = await vi.importActual('react');
+    const { Text, Box } = await vi.importActual('ink');
+    return {
+        default: ({ items, onSelect: _onSelect, initialIndex = 0, }) => {
+            return React.createElement(Box, { flexDirection: 'column' }, items.map((item, index) => {
+                // Simulate selection for first item automatically in tests
+                if (index === 0 && initialIndex === 0) {
+                    // onSelect will be called through the component's logic
+                }
+                return React.createElement(Text, {
+                    key: index,
+                }, `${index === 0 ? '❯ ' : '  '}${item.label}`);
+            }));
+        },
+    };
+});
+// Mock shortcutManager
+vi.mock('../services/shortcutManager.js', () => ({
+    shortcutManager: {
+        getShortcutDisplay: vi.fn().mockReturnValue('ESC'),
+        matchesShortcut: vi.fn().mockReturnValue(false),
+    },
+}));
+describe('RemoteBranchSelector Component', () => {
+    const mockBranchName = 'feature/awesome-feature';
+    const mockMatches = [
+        {
+            remote: 'origin',
+            branch: 'feature/awesome-feature',
+            fullRef: 'origin/feature/awesome-feature',
+        },
+        {
+            remote: 'upstream',
+            branch: 'feature/awesome-feature',
+            fullRef: 'upstream/feature/awesome-feature',
+        },
+    ];
+    let onSelect;
+    let onCancel;
+    beforeEach(() => {
+        onSelect = vi.fn();
+        onCancel = vi.fn();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should render warning title and branch name', () => {
+        const { lastFrame } = render(React.createElement(RemoteBranchSelector, { branchName: mockBranchName, matches: mockMatches, onSelect: onSelect, onCancel: onCancel }));
+        const output = lastFrame();
+        expect(output).toContain('⚠️ Ambiguous Branch Reference');
+        expect(output).toContain(`Branch 'feature/awesome-feature' exists in multiple remotes`);
+    });
+    it('should render all remote branch options', () => {
+        const { lastFrame } = render(React.createElement(RemoteBranchSelector, { branchName: mockBranchName, matches: mockMatches, onSelect: onSelect, onCancel: onCancel }));
+        const output = lastFrame();
+        expect(output).toContain('origin/feature/awesome-feature (from origin)');
+        expect(output).toContain('upstream/feature/awesome-feature (from upstream)');
+    });
+    it('should render cancel option', () => {
+        const { lastFrame } = render(React.createElement(RemoteBranchSelector, { branchName: mockBranchName, matches: mockMatches, onSelect: onSelect, onCancel: onCancel }));
+        const output = lastFrame();
+        expect(output).toContain('← Cancel');
+    });
+    it('should display help text with shortcut information', () => {
+        const { lastFrame } = render(React.createElement(RemoteBranchSelector, { branchName: mockBranchName, matches: mockMatches, onSelect: onSelect, onCancel: onCancel }));
+        const output = lastFrame();
+        expect(output).toContain('Press ↑↓ to navigate, Enter to select, ESC to cancel');
+    });
+    it('should handle single remote branch match', () => {
+        const singleMatch = [
+            {
+                remote: 'origin',
+                branch: 'feature/single-feature',
+                fullRef: 'origin/feature/single-feature',
+            },
+        ];
+        const { lastFrame } = render(React.createElement(RemoteBranchSelector, { branchName: "feature/single-feature", matches: singleMatch, onSelect: onSelect, onCancel: onCancel }));
+        const output = lastFrame();
+        expect(output).toContain('origin/feature/single-feature (from origin)');
+        expect(output).not.toContain('upstream');
+    });
+    it('should handle complex branch names with multiple slashes', () => {
+        const complexMatches = [
+            {
+                remote: 'origin',
+                branch: 'feature/sub/complex-branch-name',
+                fullRef: 'origin/feature/sub/complex-branch-name',
+            },
+            {
+                remote: 'fork',
+                branch: 'feature/sub/complex-branch-name',
+                fullRef: 'fork/feature/sub/complex-branch-name',
+            },
+        ];
+        const { lastFrame } = render(React.createElement(RemoteBranchSelector, { branchName: "feature/sub/complex-branch-name", matches: complexMatches, onSelect: onSelect, onCancel: onCancel }));
+        const output = lastFrame();
+        expect(output).toContain('origin/feature/sub/complex-branch-name (from origin)');
+        expect(output).toContain('fork/feature/sub/complex-branch-name (from fork)');
+    });
+    it('should handle many remote matches', () => {
+        const manyMatches = [
+            { remote: 'origin', branch: 'test-branch', fullRef: 'origin/test-branch' },
+            {
+                remote: 'upstream',
+                branch: 'test-branch',
+                fullRef: 'upstream/test-branch',
+            },
+            { remote: 'fork1', branch: 'test-branch', fullRef: 'fork1/test-branch' },
+            { remote: 'fork2', branch: 'test-branch', fullRef: 'fork2/test-branch' },
+            {
+                remote: 'company',
+                branch: 'test-branch',
+                fullRef: 'company/test-branch',
+            },
+        ];
+        const { lastFrame } = render(React.createElement(RemoteBranchSelector, { branchName: "test-branch", matches: manyMatches, onSelect: onSelect, onCancel: onCancel }));
+        const output = lastFrame();
+        // Verify all remotes are shown
+        expect(output).toContain('origin/test-branch (from origin)');
+        expect(output).toContain('upstream/test-branch (from upstream)');
+        expect(output).toContain('fork1/test-branch (from fork1)');
+        expect(output).toContain('fork2/test-branch (from fork2)');
+        expect(output).toContain('company/test-branch (from company)');
+    });
+    // Note: Testing actual selection behavior is complex with ink-testing-library
+    // as it requires simulating user interactions. The component logic is tested
+    // through integration tests in App.test.tsx where we can mock the callbacks
+    // and verify they're called with the correct parameters.
+});

package/dist/services/worktreeService.d.ts

@@ -10,6 +10,21 @@ export declare class WorktreeService {
     getGitRootPath(): string;
     getDefaultBranch(): string;
     getAllBranches(): string[];
+    /**
+     * Resolves a branch name to its proper git reference.
+     * Handles multiple remotes and throws AmbiguousBranchError when disambiguation is needed.
+     *
+     * Priority order:
+     * 1. Local branch exists -> return as-is
+     * 2. Single remote branch -> return remote/branch
+     * 3. Multiple remote branches -> throw AmbiguousBranchError
+     * 4. No branches found -> return original (let git handle error)
+     */
+    private resolveBranchReference;
+    /**
+     * Gets all git remotes for this repository.
+     */
+    private getAllRemotes;
     createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): Promise<{
         success: boolean;
         error?: string;

package/dist/services/worktreeService.js

@@ -1,6 +1,7 @@
 import { execSync } from 'child_process';
 import { existsSync, statSync, cpSync } from 'fs';
 import path from 'path';
+import { AmbiguousBranchError, } from '../types/index.js';
 import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
 import { getClaudeProjectsDir, pathToClaudeProjectName, } from '../utils/claudeDir.js';
 import { executeWorktreePostCreationHook } from '../utils/hookExecutor.js';
@@ -190,6 +191,93 @@ export class WorktreeService {
             return [];
         }
     }
+    /**
+     * Resolves a branch name to its proper git reference.
+     * Handles multiple remotes and throws AmbiguousBranchError when disambiguation is needed.
+     *
+     * Priority order:
+     * 1. Local branch exists -> return as-is
+     * 2. Single remote branch -> return remote/branch
+     * 3. Multiple remote branches -> throw AmbiguousBranchError
+     * 4. No branches found -> return original (let git handle error)
+     */
+    resolveBranchReference(branchName) {
+        try {
+            // First check if local branch exists (highest priority)
+            try {
+                execSync(`git show-ref --verify --quiet refs/heads/${branchName}`, {
+                    cwd: this.rootPath,
+                    encoding: 'utf8',
+                });
+                // Local branch exists, use it as-is
+                return branchName;
+            }
+            catch {
+                // Local branch doesn't exist, check remotes
+            }
+            // Get all remotes
+            const remotes = this.getAllRemotes();
+            const remoteBranchMatches = [];
+            // Check each remote for the branch
+            for (const remote of remotes) {
+                try {
+                    execSync(`git show-ref --verify --quiet refs/remotes/${remote}/${branchName}`, {
+                        cwd: this.rootPath,
+                        encoding: 'utf8',
+                    });
+                    // Remote branch exists
+                    remoteBranchMatches.push({
+                        remote,
+                        branch: branchName,
+                        fullRef: `${remote}/${branchName}`,
+                    });
+                }
+                catch {
+                    // This remote doesn't have the branch, continue
+                }
+            }
+            // Handle results based on number of matches
+            if (remoteBranchMatches.length === 0) {
+                // No remote branches found, return original (let git handle the error)
+                return branchName;
+            }
+            else if (remoteBranchMatches.length === 1) {
+                // Single remote branch found, use it
+                return remoteBranchMatches[0].fullRef;
+            }
+            else {
+                // Multiple remote branches found, throw ambiguous error
+                throw new AmbiguousBranchError(branchName, remoteBranchMatches);
+            }
+        }
+        catch (error) {
+            // Re-throw AmbiguousBranchError as-is
+            if (error instanceof AmbiguousBranchError) {
+                throw error;
+            }
+            // For any other error, return original branch name
+            return branchName;
+        }
+    }
+    /**
+     * Gets all git remotes for this repository.
+     */
+    getAllRemotes() {
+        try {
+            const output = execSync('git remote', {
+                cwd: this.rootPath,
+                encoding: 'utf8',
+            });
+            return output
+                .trim()
+                .split('\n')
+                .filter(remote => remote.length > 0);
+        }
+        catch {
+            // If git remote fails, return empty array
+            return [];
+        }
+    }
     async createWorktree(worktreePath, branch, baseBranch, copySessionData = false, copyClaudeDirectory = false) {
         try {
             // Resolve the worktree path relative to the git repository root
@@ -214,8 +302,27 @@ export class WorktreeService {
                 command = `git worktree add "${resolvedPath}" "${branch}"`;
             }
             else {
-                // Create new branch from specified base branch
-                command = `git worktree add -b "${branch}" "${resolvedPath}" "${baseBranch}"`;
+                // Resolve the base branch to its proper git reference
+                try {
+                    const resolvedBaseBranch = this.resolveBranchReference(baseBranch);
+                    // Create new branch from specified base branch
+                    command = `git worktree add -b "${branch}" "${resolvedPath}" "${resolvedBaseBranch}"`;
+                }
+                catch (error) {
+                    if (error instanceof AmbiguousBranchError) {
+                        // TODO: Future enhancement - show disambiguation modal in UI
+                        // The UI should present the available remote options to the user:
+                        // - origin/foo/bar-xyz
+                        // - upstream/foo/bar-xyz
+                        // For now, return error message to be displayed to user
+                        return {
+                            success: false,
+                            error: error.message,
+                        };
+                    }
+                    // Re-throw any other errors
+                    throw error;
+                }
             }
             execSync(command, {
                 cwd: this.gitRootPath, // Execute from git root to ensure proper resolution

package/dist/services/worktreeService.test.js

@@ -192,6 +192,122 @@ origin/feature/test
             expect(result).toEqual([]);
         });
     });
+    describe('resolveBranchReference', () => {
+        it('should return local branch when it exists', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/foo/bar-xyz')) {
+                        return ''; // Local branch exists
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = service.resolveBranchReference('foo/bar-xyz');
+            expect(result).toBe('foo/bar-xyz');
+        });
+        it('should return single remote branch when local does not exist', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/foo/bar-xyz')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/foo/bar-xyz')) {
+                        return ''; // Remote branch exists in origin
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/upstream/foo/bar-xyz')) {
+                        throw new Error('Remote branch not found in upstream');
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = service.resolveBranchReference('foo/bar-xyz');
+            expect(result).toBe('origin/foo/bar-xyz');
+        });
+        it('should throw AmbiguousBranchError when multiple remotes have the branch', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/foo/bar-xyz')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/foo/bar-xyz') ||
+                        cmd.includes('show-ref --verify --quiet refs/remotes/upstream/foo/bar-xyz')) {
+                        return ''; // Both remotes have the branch
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            expect(() => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                service.resolveBranchReference('foo/bar-xyz');
+            }).toThrow("Ambiguous branch 'foo/bar-xyz' found in multiple remotes: origin/foo/bar-xyz, upstream/foo/bar-xyz. Please specify which remote to use.");
+        });
+        it('should return original branch name when no branches exist', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\n';
+                    }
+                }
+                throw new Error('Branch not found');
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = service.resolveBranchReference('nonexistent-branch');
+            expect(result).toBe('nonexistent-branch');
+        });
+        it('should handle no remotes gracefully', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git remote') {
+                        return ''; // No remotes
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = service.resolveBranchReference('some-branch');
+            expect(result).toBe('some-branch');
+        });
+        it('should prefer local branch over remote branches', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/foo/bar-xyz')) {
+                        return ''; // Local branch exists
+                    }
+                    // Remote commands should not be called when local exists
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = service.resolveBranchReference('foo/bar-xyz');
+            expect(result).toBe('foo/bar-xyz');
+        });
+    });
     describe('createWorktree', () => {
         it('should create worktree with base branch when branch does not exist', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
@@ -227,6 +343,33 @@ origin/feature/test
             expect(result).toEqual({ success: true });
             expect(execSync).toHaveBeenCalledWith('git worktree add "/path/to/worktree" "existing-feature"', expect.any(Object));
         });
+        it('should handle ambiguous branch error gracefully', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('rev-parse --verify new-feature')) {
+                        throw new Error('Branch not found');
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/foo/bar-xyz')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/foo/bar-xyz') ||
+                        cmd.includes('show-ref --verify --quiet refs/remotes/upstream/foo/bar-xyz')) {
+                        return ''; // Both remotes have the branch
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'foo/bar-xyz');
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("Ambiguous branch 'foo/bar-xyz' found in multiple remotes");
+            expect(result.error).toContain('origin/foo/bar-xyz, upstream/foo/bar-xyz');
+        });
         it('should create worktree from specified base branch when branch does not exist', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
@@ -544,4 +687,183 @@ branch refs/heads/other-branch
             expect(mockedExecuteHook).toHaveBeenCalled();
         });
     });
+    describe('AmbiguousBranchError Integration', () => {
+        it('should return error message when createWorktree encounters ambiguous branch', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('rev-parse --verify new-feature')) {
+                        throw new Error('Branch not found');
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/ambiguous-branch')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/ambiguous-branch') ||
+                        cmd.includes('show-ref --verify --quiet refs/remotes/upstream/ambiguous-branch')) {
+                        return ''; // Both remotes have the branch
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'ambiguous-branch');
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("Ambiguous branch 'ambiguous-branch' found in multiple remotes");
+            expect(result.error).toContain('origin/ambiguous-branch, upstream/ambiguous-branch');
+            expect(result.error).toContain('Please specify which remote to use');
+        });
+        it('should successfully create worktree with resolved remote reference', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('rev-parse --verify new-feature')) {
+                        throw new Error('Branch not found');
+                    }
+                    // Simulate resolved reference (origin/ambiguous-branch) exists
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/origin/ambiguous-branch')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/origin/ambiguous-branch')) {
+                        throw new Error('Remote branch not found'); // This is expected for resolved reference
+                    }
+                    // Mock successful worktree creation with resolved reference
+                    if (cmd.includes('git worktree add -b "new-feature" "/path/to/worktree" "origin/ambiguous-branch"')) {
+                        return '';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            mockedExistsSync.mockReturnValue(false);
+            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'origin/ambiguous-branch');
+            expect(result.success).toBe(true);
+            expect(mockedExecSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "origin/ambiguous-branch"', { cwd: '/fake/path', encoding: 'utf8' });
+        });
+        it('should handle three-way ambiguous branch scenario', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('rev-parse --verify test-branch')) {
+                        throw new Error('Branch not found');
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/three-way-branch')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\nfork\n';
+                    }
+                    // All three remotes have the branch
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/three-way-branch') ||
+                        cmd.includes('show-ref --verify --quiet refs/remotes/upstream/three-way-branch') ||
+                        cmd.includes('show-ref --verify --quiet refs/remotes/fork/three-way-branch')) {
+                        return '';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = await service.createWorktree('/path/to/worktree', 'test-branch', 'three-way-branch');
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("Ambiguous branch 'three-way-branch' found in multiple remotes");
+            expect(result.error).toContain('origin/three-way-branch, upstream/three-way-branch, fork/three-way-branch');
+        });
+        it('should handle complex branch names with slashes in ambiguous scenario', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('rev-parse --verify new-feature')) {
+                        throw new Error('Branch not found');
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/feature/sub/complex-name')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nfork\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/feature/sub/complex-name') ||
+                        cmd.includes('show-ref --verify --quiet refs/remotes/fork/feature/sub/complex-name')) {
+                        return '';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'feature/sub/complex-name');
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("Ambiguous branch 'feature/sub/complex-name' found in multiple remotes");
+            expect(result.error).toContain('origin/feature/sub/complex-name, fork/feature/sub/complex-name');
+        });
+        it('should successfully resolve single remote branch with slashes', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('rev-parse --verify new-feature')) {
+                        throw new Error('Branch not found');
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/feature/auto-resolve')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\n';
+                    }
+                    // Only origin has this branch
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/feature/auto-resolve')) {
+                        return '';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/upstream/feature/auto-resolve')) {
+                        throw new Error('Remote branch not found');
+                    }
+                    // Mock successful worktree creation with auto-resolved reference
+                    if (cmd.includes('git worktree add -b "new-feature" "/path/to/worktree" "origin/feature/auto-resolve"')) {
+                        return '';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            mockedExistsSync.mockReturnValue(false);
+            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'feature/auto-resolve');
+            expect(result.success).toBe(true);
+            expect(mockedExecSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "origin/feature/auto-resolve"', { cwd: '/fake/path', encoding: 'utf8' });
+        });
+        it('should prioritize local branch over remote branches', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('rev-parse --verify new-feature')) {
+                        throw new Error('Branch not found');
+                    }
+                    // Local branch exists (highest priority)
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/local-priority')) {
+                        return '';
+                    }
+                    // Remote checks should not be executed when local exists
+                    // Mock successful worktree creation with local branch
+                    if (cmd.includes('git worktree add -b "new-feature" "/path/to/worktree" "local-priority"')) {
+                        return '';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            mockedExistsSync.mockReturnValue(false);
+            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'local-priority');
+            expect(result.success).toBe(true);
+            expect(mockedExecSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "local-priority"', { cwd: '/fake/path', encoding: 'utf8' });
+            // Verify remote command was never called since local branch exists
+            expect(mockedExecSync).not.toHaveBeenCalledWith('git remote', expect.any(Object));
+        });
+    });
 });

package/dist/types/index.d.ts

@@ -133,6 +133,16 @@ export interface IProjectManager {
     clearRecentProjects(): void;
     validateGitRepository(path: string): Promise<boolean>;
 }
+export interface RemoteBranchMatch {
+    remote: string;
+    branch: string;
+    fullRef: string;
+}
+export declare class AmbiguousBranchError extends Error {
+    branchName: string;
+    matches: RemoteBranchMatch[];
+    constructor(branchName: string, matches: RemoteBranchMatch[]);
+}
 export interface IWorktreeService {
     getWorktrees(): Worktree[];
     getGitRootPath(): string;

package/dist/types/index.js

@@ -2,3 +2,23 @@ export const DEFAULT_SHORTCUTS = {
     returnToMenu: { ctrl: true, key: 'e' },
     cancel: { key: 'escape' },
 };
+export class AmbiguousBranchError extends Error {
+    constructor(branchName, matches) {
+        super(`Ambiguous branch '${branchName}' found in multiple remotes: ${matches
+            .map(m => m.fullRef)
+            .join(', ')}. Please specify which remote to use.`);
+        Object.defineProperty(this, "branchName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: branchName
+        });
+        Object.defineProperty(this, "matches", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: matches
+        });
+        this.name = 'AmbiguousBranchError';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "2.4.1",
+	"version": "2.5.1",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",