ccmanager 4.3.0 → 4.3.1

package/dist/components/App.js

@@ -672,8 +672,8 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     if (view === 'session-actions' && sessionActionsTarget) {
         const { session: targetSession, worktreePath } = sessionActionsTarget;
         const label = targetSession.sessionName
-            ? `${worktreePath} : ${targetSession.sessionName}`
-            : `${worktreePath} #${targetSession.sessionNumber}`;
+            ? targetSession.sessionName
+            : `Session #${targetSession.sessionNumber}`;
         const handleSessionAction = async (action) => {
             setSessionActionsTarget(null);
             switch (action) {
@@ -698,7 +698,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
                     return;
             }
         };
-        return (_jsx(SessionActions, { sessionLabel: label, onSelect: handleSessionAction, onCancel: () => {
+        return (_jsx(SessionActions, { sessionLabel: label, worktreePath: worktreePath, onSelect: handleSessionAction, onCancel: () => {
                 setSessionActionsTarget(null);
                 handleReturnToMenu();
             } }));

package/dist/components/NewWorktree.js

@@ -10,6 +10,7 @@ import { WorktreeService } from '../services/worktreeService.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
 import SearchableList from './SearchableList.js';
+import RemoteBranchSelector from './RemoteBranchSelector.js';
 import { Effect } from 'effect';
 import { describePromptInjection, getPromptInjectionMethod, } from '../utils/presetPrompt.js';
 const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
@@ -28,6 +29,10 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const [path, setPath] = useState('');
     const [branch, setBranch] = useState('');
     const [baseBranch, setBaseBranch] = useState('');
+    // Short branch name to use when creating a local branch from baseBranch
+    // (differs from baseBranch when baseBranch is a remote ref like "origin/x")
+    const [baseBranchLocalName, setBaseBranchLocalName] = useState('');
+    const [ambiguousBase, setAmbiguousBase] = useState(null);
     const [copyClaudeDirectory, setCopyClaudeDirectory] = useState(true);
     const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
     const [selectedPresetId, setSelectedPresetId] = useState(presetsConfig.defaultPresetId);
@@ -37,9 +42,10 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const [branches, setBranches] = useState([]);
     const [remoteBranches, setRemoteBranches] = useState([]);
     const [defaultBranch, setDefaultBranch] = useState('main');
+    const worktreeService = useMemo(() => new WorktreeService(projectPath), [projectPath]);
     useEffect(() => {
         let cancelled = false;
-        const service = new WorktreeService(projectPath);
+        const service = worktreeService;
         const loadBranches = async () => {
             const branchesEffect = includeRemoteBranches
                 ? service.getBranchesWithRemotesEffect()
@@ -70,8 +76,15 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
                     setRemoteBranches(result.remote);
                     setDefaultBranch(result.defaultBranch);
                     setIsLoadingBranches(false);
-                    if (isAutoUseDefaultBranch && result.defaultBranch) {
-                        setBaseBranch(result.defaultBranch);
+                    // When the default branch is ambiguous across remotes we can't
+                    // pick one silently, so keep the base-branch step and let the
+                    // user choose.
+                    const resolution = isAutoUseDefaultBranch && result.defaultBranch
+                        ? service.resolveBaseBranch(result.defaultBranch)
+                        : null;
+                    if (resolution && resolution.kind !== 'ambiguous') {
+                        setBaseBranch(resolution.ref);
+                        setBaseBranchLocalName(resolution.localName);
                         setStep(currentStep => currentStep === 'base-branch' ? 'creation-mode' : currentStep);
                     }
                 }
@@ -86,7 +99,7 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
         return () => {
             cancelled = true;
         };
-    }, [projectPath, isAutoUseDefaultBranch, includeRemoteBranches]);
+    }, [worktreeService, isAutoUseDefaultBranch, includeRemoteBranches]);
     const allBranchItems = useMemo(() => {
         const defaultRemoteSuffix = `/${defaultBranch}`;
         const defaultRemotes = remoteBranches.filter(br => br.endsWith(defaultRemoteSuffix));
@@ -123,6 +136,11 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const selectedPreset = useMemo(() => presetsConfig.presets.find(preset => preset.id === selectedPresetId) ||
         presetsConfig.presets[0], [selectedPresetId, presetsConfig.presets]);
     useInput((input, key) => {
+        if (step === 'remote-branch-confirm') {
+            // RemoteBranchSelector handles its own cancel shortcut (returns to
+            // the base-branch list); don't also cancel the whole wizard here.
+            return;
+        }
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
             onCancel();
         }
@@ -130,22 +148,57 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
             return;
         }
     });
+    /**
+     * Resolves the selected base branch right away. Returns true when the
+     * selection is settled; returns false when the branch exists on multiple
+     * remotes, in which case the remote-branch-confirm step is shown so the
+     * user can disambiguate immediately (instead of failing later when the
+     * worktree is actually created).
+     */
+    const applyBaseBranchSelection = (name) => {
+        const resolution = worktreeService.resolveBaseBranch(name);
+        if (resolution.kind === 'ambiguous') {
+            setAmbiguousBase({
+                branchName: resolution.branchName,
+                matches: resolution.matches,
+            });
+            setStep('remote-branch-confirm');
+            return false;
+        }
+        setBaseBranch(resolution.ref);
+        setBaseBranchLocalName(resolution.localName);
+        return true;
+    };
     const handlePathSubmit = (value) => {
         if (!value.trim())
             return;
         setPath(value.trim());
         if (isAutoUseDefaultBranch && defaultBranch) {
-            setBaseBranch(defaultBranch);
-            setStep('creation-mode');
+            if (applyBaseBranchSelection(defaultBranch)) {
+                setStep('creation-mode');
+            }
         }
         else {
             setStep('base-branch');
         }
     };
     const handleBaseBranchSelect = (item) => {
-        setBaseBranch(item.value);
+        if (applyBaseBranchSelection(item.value)) {
+            setStep('creation-mode');
+        }
+    };
+    const handleAmbiguousBaseSelect = (selectedRemoteRef) => {
+        if (!ambiguousBase)
+            return;
+        setBaseBranch(selectedRemoteRef);
+        setBaseBranchLocalName(ambiguousBase.branchName);
+        setAmbiguousBase(null);
         setStep('creation-mode');
     };
+    const handleAmbiguousBaseCancel = () => {
+        setAmbiguousBase(null);
+        setStep('base-branch');
+    };
     const handleCreationModeSelect = (item) => {
         if (item.value === 'manual') {
             setStep('branch-strategy');
@@ -156,7 +209,10 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const handleBranchStrategySelect = (item) => {
         const useExisting = item.value === 'existing';
         if (useExisting) {
-            setBranch(baseBranch);
+            // Use the short branch name: when baseBranch is a remote ref
+            // (e.g. "origin/feature/x"), the local branch to attach/create is
+            // "feature/x", not a branch literally named "origin/feature/x".
+            setBranch(baseBranchLocalName || baseBranch);
             setStep('copy-settings');
         }
         else {
@@ -264,7 +320,7 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const promptMethod = selectedPreset
         ? getPromptInjectionMethod(selectedPreset)
         : 'stdin';
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), step === 'path' && !isAutoDirectory ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter worktree path (relative to repository root):" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: 'Tip: Enable "Auto Directory" in settings to generate paths automatically from branch names.' }) })] })) : null, step === 'base-branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select base branch for the worktree:" }) }), _jsx(SearchableList, { isSearchMode: isSearchMode, searchQuery: searchQuery, onSearchQueryChange: setSearchQuery, selectedIndex: selectedIndex, items: branchItems, limit: limit, placeholder: "Type to filter branches...", noMatchMessage: "No branches match your search", children: _jsx(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode }) }), !isSearchMode && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press / to search" }) })), includeRemoteBranches && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Tip: If the branch list feels slow, disable \"Include Remote Branches\" in Configuration \u2192 Configure Worktree Settings." }) }))] })), step === 'creation-mode' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "How do you want to create the new worktree?" }) }), _jsx(SelectInput, { items: [
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), step === 'path' && !isAutoDirectory ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter worktree path (relative to repository root):" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: 'Tip: Enable "Auto Directory" in settings to generate paths automatically from branch names.' }) })] })) : null, step === 'base-branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select base branch for the worktree:" }) }), _jsx(SearchableList, { isSearchMode: isSearchMode, searchQuery: searchQuery, onSearchQueryChange: setSearchQuery, selectedIndex: selectedIndex, items: branchItems, limit: limit, placeholder: "Type to filter branches...", noMatchMessage: "No branches match your search", children: _jsx(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode }) }), !isSearchMode && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press / to search" }) })), includeRemoteBranches && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Tip: If the branch list feels slow, disable \"Include Remote Branches\" in Configuration \u2192 Configure Worktree Settings." }) }))] })), step === 'remote-branch-confirm' && ambiguousBase && (_jsx(RemoteBranchSelector, { branchName: ambiguousBase.branchName, matches: ambiguousBase.matches, onSelect: handleAmbiguousBaseSelect, onCancel: handleAmbiguousBaseCancel })), step === 'creation-mode' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "How do you want to create the new worktree?" }) }), _jsx(SelectInput, { items: [
                             {
                                 label: '1. Choose the branch name yourself',
                                 value: 'manual',
@@ -291,6 +347,6 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
                         ], onSelect: handleCopySettingsSelect, initialIndex: 0 })] })), step === 'copy-session' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Copy Claude Code session data to the new worktree?" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "This will copy conversation history and context from the current worktree." }) }), isAutoDirectory && generatedPath ? (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: ["Worktree path preview:", ' ', _jsx(Text, { color: "green", children: generatedPath })] }) })) : null, _jsx(SelectInput, { items: [
                             { label: '✅ Yes, copy session data', value: 'yes' },
                             { label: '❌ No, start fresh', value: 'no' },
-                        ], onSelect: handleCopySessionSelect, initialIndex: copySessionData ? 0 : 1 })] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to cancel"] }) })] }));
+                        ], onSelect: handleCopySessionSelect, initialIndex: copySessionData ? 0 : 1 })] })), step !== 'remote-branch-confirm' && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to cancel"] }) }))] }));
 };
 export default NewWorktree;

package/dist/components/NewWorktree.test.js

@@ -289,6 +289,11 @@ describe('NewWorktree component Effect integration', () => {
             return {
                 getAllBranchesEffect: vi.fn(() => Effect.succeed(mockBranches)),
                 getDefaultBranchEffect: vi.fn(() => Effect.succeed(mockDefaultBranch)),
+                resolveBaseBranch: vi.fn((name) => ({
+                    kind: 'local',
+                    ref: name,
+                    localName: name,
+                })),
             };
         });
         const onComplete = vi.fn();
@@ -305,6 +310,38 @@ describe('NewWorktree component Effect integration', () => {
         expect(output).toContain('Choose the branch name yourself');
         expect(output).toContain('Enter a prompt first');
     });
+    it('should keep the base branch selection when the default branch is ambiguous across remotes', async () => {
+        const { Effect } = await import('effect');
+        const { WorktreeService } = await import('../services/worktreeService.js');
+        const { configReader } = await import('../services/config/configReader.js');
+        vi.spyOn(configReader, 'getWorktreeConfig').mockReturnValue({
+            autoDirectory: true,
+            autoDirectoryPattern: '../{project}-{branch}',
+            copySessionData: true,
+            autoUseDefaultBranch: true,
+        });
+        // Default branch has no local ref and exists on two remotes: it cannot
+        // be picked silently, so the base-branch step must not be skipped.
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getAllBranchesEffect: vi.fn(() => Effect.succeed(['main', 'develop'])),
+                getDefaultBranchEffect: vi.fn(() => Effect.succeed('main')),
+                resolveBaseBranch: vi.fn(() => ({
+                    kind: 'ambiguous',
+                    branchName: 'main',
+                    matches: [
+                        { remote: 'origin', branch: 'main', fullRef: 'origin/main' },
+                        { remote: 'upstream', branch: 'main', fullRef: 'upstream/main' },
+                    ],
+                })),
+            };
+        });
+        const { lastFrame } = render(_jsx(NewWorktree, { onComplete: vi.fn(), onCancel: vi.fn() }));
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const output = lastFrame();
+        expect(output).toContain('Select base branch');
+        expect(output).not.toContain('How do you want to create the new worktree?');
+    });
     it('should show base branch selection when autoUseDefaultBranch is disabled', async () => {
         const { Effect } = await import('effect');
         const { WorktreeService } = await import('../services/worktreeService.js');

package/dist/components/SessionActions.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 export type SessionActionType = 'newSession' | 'rename' | 'kill';
 interface SessionActionsProps {
     sessionLabel: string;
+    worktreePath: string;
     onSelect: (action: SessionActionType) => void;
     onCancel: () => void;
 }

package/dist/components/SessionActions.js

@@ -6,7 +6,7 @@ const items = [
     { label: 'R  Rename this session', value: 'rename' },
     { label: 'X  Close session', value: 'kill' },
 ];
-const SessionActions = ({ sessionLabel, onSelect, onCancel, }) => {
+const SessionActions = ({ sessionLabel, worktreePath, onSelect, onCancel, }) => {
     useInput((input, key) => {
         if (key.escape) {
             onCancel();
@@ -24,6 +24,6 @@ const SessionActions = ({ sessionLabel, onSelect, onCancel, }) => {
                 break;
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Session Actions" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: sessionLabel }) }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: items, onSelect: item => onSelect(item.value) }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "S/R/X or arrow keys + Enter | Escape to cancel" }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Session Actions" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: sessionLabel }), _jsxs(Text, { dimColor: true, children: ["Directory: ", worktreePath] })] }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: items, onSelect: item => onSelect(item.value) }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "S/R/X or arrow keys + Enter | Escape to cancel" }) })] }));
 };
 export default SessionActions;

package/dist/services/worktreeService.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from 'effect';
-import { Worktree, CreateWorktreeResult, AmbiguousBranchError, MergeConfig } from '../types/index.js';
+import { Worktree, CreateWorktreeResult, AmbiguousBranchError, BaseBranchResolution, MergeConfig } from '../types/index.js';
 import { GitError, FileSystemError, ProcessError } from '../types/errors.js';
 /**
  * WorktreeService - Git worktree management with Effect-based error handling
@@ -54,6 +54,21 @@ export declare class WorktreeService {
      */
     private resolveBranchReference;
     private resolveBranchReferenceEffect;
+    /**
+     * Classifies a base branch picked in the UI, without throwing.
+     *
+     * Unlike resolveBranchReference(), this is meant to run right after the
+     * user selects a base branch so that:
+     * - a local branch is confirmed immediately (never routed to the
+     *   ambiguous-remote confirmation), and
+     * - an ambiguous branch (same name in multiple remotes) can be
+     *   disambiguated right away instead of failing later at creation time.
+     *
+     * @param {string} branchName - Branch name or remote-qualified ref
+     *   (e.g. "feature/x" or "origin/feature/x") selected as base branch
+     * @returns {BaseBranchResolution} Classification result (see type docs)
+     */
+    resolveBaseBranch(branchName: string): BaseBranchResolution;
     /**
      * SYNCHRONOUS HELPER: Gets all git remotes for this repository.
      *

package/dist/services/worktreeService.js

@@ -174,6 +174,79 @@ export class WorktreeService {
             },
         });
     }
+    /**
+     * Classifies a base branch picked in the UI, without throwing.
+     *
+     * Unlike resolveBranchReference(), this is meant to run right after the
+     * user selects a base branch so that:
+     * - a local branch is confirmed immediately (never routed to the
+     *   ambiguous-remote confirmation), and
+     * - an ambiguous branch (same name in multiple remotes) can be
+     *   disambiguated right away instead of failing later at creation time.
+     *
+     * @param {string} branchName - Branch name or remote-qualified ref
+     *   (e.g. "feature/x" or "origin/feature/x") selected as base branch
+     * @returns {BaseBranchResolution} Classification result (see type docs)
+     */
+    resolveBaseBranch(branchName) {
+        // Local branch has the highest priority
+        try {
+            execSync(`git show-ref --verify --quiet refs/heads/${branchName}`, {
+                cwd: this.rootPath,
+                encoding: 'utf8',
+            });
+            return { kind: 'local', ref: branchName, localName: branchName };
+        }
+        catch {
+            // Not a local branch, check remotes below
+        }
+        const remotes = this.getAllRemotes();
+        // Already remote-qualified (e.g. "origin/feature/x" selected from the
+        // remote section of the branch list): not ambiguous by construction.
+        for (const remote of remotes) {
+            const prefix = `${remote}/`;
+            if (!branchName.startsWith(prefix))
+                continue;
+            try {
+                execSync(`git show-ref --verify --quiet refs/remotes/${branchName}`, {
+                    cwd: this.rootPath,
+                    encoding: 'utf8',
+                });
+                return {
+                    kind: 'remote',
+                    ref: branchName,
+                    localName: branchName.slice(prefix.length),
+                };
+            }
+            catch {
+                // Not an existing remote-tracking ref; fall through to matching
+            }
+        }
+        const matches = [];
+        for (const remote of remotes) {
+            try {
+                execSync(`git show-ref --verify --quiet refs/remotes/${remote}/${branchName}`, {
+                    cwd: this.rootPath,
+                    encoding: 'utf8',
+                });
+                matches.push({
+                    remote,
+                    branch: branchName,
+                    fullRef: `${remote}/${branchName}`,
+                });
+            }
+            catch {
+                // This remote doesn't have the branch, continue
+            }
+        }
+        if (matches.length === 1) {
+            return { kind: 'remote', ref: matches[0].fullRef, localName: branchName };
+        }
+        if (matches.length > 1) {
+            return { kind: 'ambiguous', branchName, matches };
+        }
+        return { kind: 'none', ref: branchName, localName: branchName };
+    }
     /**
      * SYNCHRONOUS HELPER: Gets all git remotes for this repository.
      *
@@ -831,7 +904,13 @@ export class WorktreeService {
                 command = `git worktree add -b "${branch}" "${resolvedPath}" "${baseBranch}"`;
             }
             else {
-                const resolvedRef = yield* self.resolveBranchReferenceEffect(branch);
+                // The new branch name itself may match remote branches (checkout
+                // semantics: typing "feature/x" checks out origin/feature/x when it
+                // exists on exactly one remote). When the name exists on MULTIPLE
+                // remotes, don't fail with AmbiguousBranchError: the user already
+                // chose baseBranch explicitly, so create the new branch from
+                // baseBranch instead of asking which remote to track.
+                const resolvedRef = yield* Effect.catchAll(self.resolveBranchReferenceEffect(branch), () => Effect.succeed(branch));
                 const isRemoteBranch = resolvedRef !== branch;
                 const startPoint = isRemoteBranch
                     ? resolvedRef

package/dist/services/worktreeService.test.js

@@ -425,6 +425,133 @@ origin/feature/test
             }
         });
     });
+    describe('resolveBaseBranch', () => {
+        it('should classify a local branch as local without checking remotes', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git show-ref --verify --quiet refs/heads/feature/x') {
+                        return ''; // Local branch exists
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = service.resolveBaseBranch('feature/x');
+            expect(result).toEqual({
+                kind: 'local',
+                ref: 'feature/x',
+                localName: 'feature/x',
+            });
+        });
+        it('should classify a remote-qualified ref as remote with the short local name', () => {
+            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/')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\n';
+                    }
+                    if (cmd ===
+                        'git show-ref --verify --quiet refs/remotes/origin/feature/x') {
+                        return '';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = service.resolveBaseBranch('origin/feature/x');
+            expect(result).toEqual({
+                kind: 'remote',
+                ref: 'origin/feature/x',
+                localName: 'feature/x',
+            });
+        });
+        it('should classify a branch existing on a single remote as remote', () => {
+            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/')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\n';
+                    }
+                    if (cmd ===
+                        'git show-ref --verify --quiet refs/remotes/origin/feature/x') {
+                        return '';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/')) {
+                        throw new Error('Remote branch not found');
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = service.resolveBaseBranch('feature/x');
+            expect(result).toEqual({
+                kind: 'remote',
+                ref: 'origin/feature/x',
+                localName: 'feature/x',
+            });
+        });
+        it('should classify a branch existing on multiple remotes as ambiguous', () => {
+            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/')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/')) {
+                        return ''; // Both remotes have the branch
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = service.resolveBaseBranch('feature/x');
+            expect(result).toEqual({
+                kind: 'ambiguous',
+                branchName: 'feature/x',
+                matches: [
+                    { remote: 'origin', branch: 'feature/x', fullRef: 'origin/feature/x' },
+                    {
+                        remote: 'upstream',
+                        branch: 'feature/x',
+                        fullRef: 'upstream/feature/x',
+                    },
+                ],
+            });
+        });
+        it('should classify an unknown branch as none', () => {
+            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');
+            });
+            const result = service.resolveBaseBranch('nonexistent');
+            expect(result).toEqual({
+                kind: 'none',
+                ref: 'nonexistent',
+                localName: 'nonexistent',
+            });
+        });
+    });
     describe('hasClaudeDirectoryInBranchEffect', () => {
         it('should return Effect with true when .claude directory exists in branch worktree', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
@@ -751,7 +878,43 @@ branch refs/heads/feature
             expect(worktreeAddCmd).toContain('-b "feature/remote-only"');
             expect(worktreeAddCmd).toContain('"origin/feature/remote-only"');
         });
-        it('should return Effect Left with AmbiguousBranchError when branch exists in multiple remotes', async () => {
+        it('should fall back to baseBranch when the new branch name exists in multiple remotes', async () => {
+            const executedCommands = [];
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    executedCommands.push(cmd);
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    // baseBranch "main" exists locally; the new branch does not
+                    if (cmd === 'git show-ref --verify --quiet refs/heads/main') {
+                        return '';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/')) {
+                        throw new Error('Branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nkbwo-fork\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/')) {
+                        return ''; // Both remotes have the new branch name
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                }
+                return '';
+            });
+            // The user explicitly chose "main" as base branch; the ambiguity of
+            // "feature/feed-mention" across remotes must not fail the creation.
+            const effect = service.createWorktreeEffect('/path/to/worktree', 'feature/feed-mention', 'main');
+            const result = await Effect.runPromise(Effect.either(effect));
+            expect(result._tag).toBe('Right');
+            const worktreeAddCmd = executedCommands.find(c => c.includes('git worktree add'));
+            expect(worktreeAddCmd).toContain('-b "feature/feed-mention"');
+            expect(worktreeAddCmd).toContain('"main"');
+        });
+        it('should return Effect Left with AmbiguousBranchError when baseBranch exists in multiple remotes', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -763,13 +926,19 @@ branch refs/heads/feature
                     if (cmd === 'git remote') {
                         return 'origin\nkbwo-fork\n';
                     }
+                    // Only the baseBranch exists on the remotes; the new branch
+                    // name matches nothing anywhere.
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/feature/feed-mention') ||
+                        cmd.includes('show-ref --verify --quiet refs/remotes/kbwo-fork/feature/feed-mention')) {
+                        return '';
+                    }
                     if (cmd.includes('show-ref --verify --quiet refs/remotes/')) {
-                        return ''; // Both remotes have the branch
+                        throw new Error('Remote branch not found');
                     }
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            const effect = service.createWorktreeEffect('/path/to/worktree', 'feature/feed-mention', 'main');
+            const effect = service.createWorktreeEffect('/path/to/worktree', 'new-feature', 'feature/feed-mention');
             const result = await Effect.runPromise(Effect.either(effect));
             expect(result._tag).toBe('Left');
             if (result._tag === 'Left') {

package/dist/types/index.d.ts

@@ -249,6 +249,33 @@ export interface RemoteBranchMatch {
     branch: string;
     fullRef: string;
 }
+/**
+ * Result of classifying a base branch the user picked in the UI.
+ *
+ * - 'local': branch exists locally; `ref` is the branch name as-is.
+ * - 'remote': resolved to exactly one remote-tracking ref; `ref` is the full
+ *   ref (e.g. "origin/foo") and `localName` the short branch name to use when
+ *   creating a local branch from it.
+ * - 'ambiguous': branch exists in multiple remotes; the user must pick one.
+ * - 'none': nothing matched; pass `ref` through and let git report errors.
+ */
+export type BaseBranchResolution = {
+    kind: 'local';
+    ref: string;
+    localName: string;
+} | {
+    kind: 'remote';
+    ref: string;
+    localName: string;
+} | {
+    kind: 'none';
+    ref: string;
+    localName: string;
+} | {
+    kind: 'ambiguous';
+    branchName: string;
+    matches: RemoteBranchMatch[];
+};
 export declare class AmbiguousBranchError extends Error {
     readonly _tag: "AmbiguousBranchError";
     branchName: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.3.0",
+	"version": "4.3.1",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "4.3.0",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.3.0",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.3.0",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.3.0",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.3.0"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "4.3.1",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.3.1",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.3.1",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.3.1",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.3.1"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",