ccmanager 2.5.0 → 2.6.0

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/ConfigureCommand.js

@@ -5,6 +5,20 @@ import SelectInput from 'ink-select-input';
 import { configurationManager } from '../services/configurationManager.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 import Confirmation from './Confirmation.js';
+// This function ensures all strategies are included at compile time
+const createStrategyItems = () => {
+    // This object MUST include all StateDetectionStrategy values as keys
+    // If any are missing, TypeScript will error
+    const strategies = {
+        claude: { label: 'Claude', value: 'claude' },
+        gemini: { label: 'Gemini', value: 'gemini' },
+        codex: { label: 'Codex', value: 'codex' },
+        cursor: { label: 'Cursor Agent', value: 'cursor' },
+    };
+    return Object.values(strategies);
+};
+// Type-safe strategy items that ensures all StateDetectionStrategy values are included
+const ALL_STRATEGY_ITEMS = createStrategyItems();
 const formatDetectionStrategy = (strategy) => {
     const value = strategy || 'claude';
     switch (value) {
@@ -12,6 +26,8 @@ const formatDetectionStrategy = (strategy) => {
             return 'Gemini';
         case 'codex':
             return 'Codex';
+        case 'cursor':
+            return 'Cursor';
         default:
             return 'Claude';
     }
@@ -259,11 +275,7 @@ const ConfigureCommand = ({ onComplete }) => {
         const preset = presets.find(p => p.id === selectedPresetId);
         if (!preset)
             return null;
-        const strategyItems = [
-            { label: 'Claude', value: 'claude' },
-            { label: 'Gemini', value: 'gemini' },
-            { label: 'Codex', value: 'codex' },
-        ];
+        const strategyItems = ALL_STRATEGY_ITEMS;
         const currentStrategy = preset.detectionStrategy || 'claude';
         const initialIndex = strategyItems.findIndex(item => item.value === currentStrategy);
         return (React.createElement(Box, { flexDirection: "column" },
@@ -308,11 +320,7 @@ const ConfigureCommand = ({ onComplete }) => {
     // Render add preset form
     if (viewMode === 'add') {
         if (isSelectingStrategyInAdd) {
-            const strategyItems = [
-                { label: 'Claude', value: 'claude' },
-                { label: 'Gemini', value: 'gemini' },
-                { label: 'Codex', value: 'codex' },
-            ];
+            const strategyItems = ALL_STRATEGY_ITEMS;
             return (React.createElement(Box, { flexDirection: "column" },
                 React.createElement(Box, { marginBottom: 1 },
                     React.createElement(Text, { bold: true, color: "green" }, "Add New Preset - Detection Strategy")),

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/stateDetector.d.ts

@@ -17,3 +17,6 @@ export declare class GeminiStateDetector extends BaseStateDetector {
 export declare class CodexStateDetector extends BaseStateDetector {
     detectState(terminal: Terminal, _currentState: SessionState): SessionState;
 }
+export declare class CursorStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+}

package/dist/services/stateDetector.js

@@ -6,6 +6,8 @@ export function createStateDetector(strategy = 'claude') {
             return new GeminiStateDetector();
         case 'codex':
             return new CodexStateDetector();
+        case 'cursor':
+            return new CursorStateDetector();
         default:
             return new ClaudeStateDetector();
     }
@@ -89,3 +91,21 @@ export class CodexStateDetector extends BaseStateDetector {
         return 'idle';
     }
 }
+export class CursorStateDetector extends BaseStateDetector {
+    detectState(terminal, _currentState) {
+        const content = this.getTerminalContent(terminal);
+        const lowerContent = content.toLowerCase();
+        // Check for waiting prompts - Priority 1
+        if (lowerContent.includes('(y) (enter)') ||
+            lowerContent.includes('keep (n)') ||
+            /auto .* \(shift\+tab\)/.test(lowerContent)) {
+            return 'waiting_input';
+        }
+        // Check for busy state - Priority 2
+        if (lowerContent.includes('ctrl+c to stop')) {
+            return 'busy';
+        }
+        // Otherwise idle - Priority 3
+        return 'idle';
+    }
+}

package/dist/services/stateDetector.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { ClaudeStateDetector, GeminiStateDetector, CodexStateDetector, } from './stateDetector.js';
+import { ClaudeStateDetector, GeminiStateDetector, CodexStateDetector, CursorStateDetector, } from './stateDetector.js';
 describe('ClaudeStateDetector', () => {
     let detector;
     let terminal;
@@ -363,3 +363,147 @@ describe('CodexStateDetector', () => {
         expect(state).toBe('waiting_input');
     });
 });
+describe('CursorStateDetector', () => {
+    let detector;
+    let terminal;
+    const createMockTerminal = (lines) => {
+        const buffer = {
+            length: lines.length,
+            active: {
+                length: lines.length,
+                getLine: (index) => {
+                    if (index >= 0 && index < lines.length) {
+                        return {
+                            translateToString: () => lines[index],
+                        };
+                    }
+                    return null;
+                },
+            },
+        };
+        return { buffer };
+    };
+    beforeEach(() => {
+        detector = new CursorStateDetector();
+    });
+    it('should detect waiting_input state for (y) (enter) pattern', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Some output',
+            'Apply changes? (y) (enter)',
+            '> ',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect waiting_input state for (Y) (ENTER) pattern (case insensitive)', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Some output',
+            'Continue? (Y) (ENTER)',
+            '> ',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect waiting_input state for Keep (n) pattern', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Changes detected',
+            'Keep (n) or replace?',
+            '> ',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect waiting_input state for KEEP (N) pattern (case insensitive)', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Some output',
+            'KEEP (N) current version?',
+            '> ',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect waiting_input state for Auto pattern with shift+tab', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Some output',
+            'Auto apply changes (shift+tab)',
+            '> ',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect waiting_input state for AUTO with SHIFT+TAB (case insensitive)', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Some output',
+            'AUTO COMPLETE (SHIFT+TAB)',
+            '> ',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect busy state for ctrl+c to stop pattern', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Processing...',
+            'Press ctrl+c to stop',
+            'Working...',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('busy');
+    });
+    it('should detect busy state for CTRL+C TO STOP (case insensitive)', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Running...',
+            'PRESS CTRL+C TO STOP',
+            'Processing...',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('busy');
+    });
+    it('should detect idle state when no patterns match', () => {
+        // Arrange
+        terminal = createMockTerminal(['Normal output', 'Some message', 'Ready']);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('idle');
+    });
+    it('should prioritize waiting_input over busy (Priority 1)', () => {
+        // Arrange
+        terminal = createMockTerminal(['ctrl+c to stop', '(y) (enter)']);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input'); // waiting_input should take precedence
+    });
+    it('should handle empty terminal', () => {
+        // Arrange
+        terminal = createMockTerminal([]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('idle');
+    });
+});

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

@@ -3,7 +3,7 @@ import type pkg from '@xterm/headless';
 import { GitStatus } from '../utils/gitStatus.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input';
-export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex';
+export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor';
 export interface Worktree {
     path: string;
     branch?: string;
@@ -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.5.0",
+	"version": "2.6.0",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",