ccmanager 4.1.18 → 4.1.20

package/dist/components/App.js

@@ -18,7 +18,6 @@ import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator
 import { WorktreeService } from '../services/worktreeService.js';
 import { worktreeNameGenerator, generateFallbackBranchName, } from '../services/worktreeNameGenerator.js';
 import { logger } from '../utils/logger.js';
-import { AmbiguousBranchError, } from '../types/index.js';
 import { configReader } from '../services/config/configReader.js';
 import { ENV_VARS } from '../constants/env.js';
 import { MULTI_PROJECT_ERRORS } from '../constants/error.js';
@@ -217,29 +216,6 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             cancelled = true;
         };
     }, [view, pendingMenuSessionLaunch, startSessionForWorktree]);
-    // 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) {
@@ -266,21 +242,8 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             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');
-        }
+        setError(result.error || 'Failed to create worktree');
+        setView('new-worktree');
     };
     const handleMenuAction = async (action) => {
         switch (action.type) {
@@ -409,9 +372,23 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         setView('creating-worktree');
         // Create the worktree using Effect
         const result = await Effect.runPromise(Effect.either(worktreeService.createWorktreeEffect(targetPath, branch, request.baseBranch, request.copySessionData, request.copyClaudeDirectory)));
-        // Transform Effect result to legacy format for handleWorktreeCreationResult
         if (result._tag === 'Left') {
-            // Handle error using pattern matching on _tag
+            if (result.left._tag === 'AmbiguousBranchError') {
+                setPendingWorktreeCreation({
+                    path: targetPath,
+                    branch,
+                    baseBranch: request.baseBranch,
+                    copySessionData: request.copySessionData,
+                    copyClaudeDirectory: request.copyClaudeDirectory,
+                    presetId: request.creationMode === 'prompt' ? request.presetId : undefined,
+                    initialPrompt: request.creationMode === 'prompt'
+                        ? request.initialPrompt
+                        : undefined,
+                    ambiguousError: result.left,
+                });
+                navigateWithClear('remote-branch-selector');
+                return;
+            }
             const errorMessage = formatPreCreationHookError(result.left);
             if (result.left._tag === 'ProcessError') {
                 setError(null);
@@ -473,7 +450,11 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         const result = await Effect.runPromise(Effect.either(worktreeService.createWorktreeEffect(creationData.path, creationData.branch, selectedRemoteRef, // Use the selected remote reference
         creationData.copySessionData, creationData.copyClaudeDirectory)));
         if (result._tag === 'Left') {
-            // Handle error using pattern matching on _tag
+            if (result.left._tag === 'AmbiguousBranchError') {
+                setError(result.left.message);
+                setView('new-worktree');
+                return;
+            }
             const errorMessage = formatPreCreationHookError(result.left);
             if (result.left._tag === 'ProcessError') {
                 setError(null);
@@ -572,6 +553,16 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         setActiveSession(session);
         navigateWithClear('session');
     };
+    const handleSessionActionFromDashboard = (session, project) => {
+        const projectSessionManager = globalSessionOrchestrator.getManagerForProject(project.path);
+        setSessionManager(projectSessionManager);
+        setWorktreeService(new WorktreeService(project.path));
+        setSessionActionsTarget({
+            session,
+            worktreePath: session.worktreePath,
+        });
+        navigateWithClear('session-actions');
+    };
     const handleBackToProjectList = () => {
         // Sessions persist in their project-specific managers
         setSelectedProject(null);
@@ -587,7 +578,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         if (!projectsDir) {
             return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", MULTI_PROJECT_ERRORS.NO_PROJECTS_DIR] }) }));
         }
-        return (_jsx(Dashboard, { projectsDir: projectsDir, onSelectSession: handleSelectSessionFromDashboard, onSelectProject: handleSelectProject, error: error, onDismissError: () => setError(null), version: version }));
+        return (_jsx(Dashboard, { projectsDir: projectsDir, onSelectSession: handleSelectSessionFromDashboard, onSelectProject: handleSelectProject, onSessionAction: handleSessionActionFromDashboard, error: error, onDismissError: () => setError(null), version: version }));
     }
     if (view === 'menu') {
         return (_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: handleMenuAction, onSelectRecentProject: handleSelectProject, error: error, onDismissError: () => setError(null), projectName: selectedProject?.name, multiProject: multiProject, version: version }, menuKey));

package/dist/components/Dashboard.d.ts

@@ -4,6 +4,7 @@ interface DashboardProps {
     projectsDir: string;
     onSelectSession: (session: ISession, project: GitProject) => void;
     onSelectProject: (project: GitProject) => void;
+    onSessionAction?: (session: ISession, project: GitProject) => void;
     error: string | null;
     onDismissError: () => void;
     version: string;

package/dist/components/Dashboard.js

@@ -12,7 +12,7 @@ import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, getStatusDisplay, } from '../c
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
 import { useGitStatus } from '../hooks/useGitStatus.js';
-import { truncateString, calculateColumnPositions, assembleSessionLabel, formatRelativeDate, } from '../utils/worktreeUtils.js';
+import { truncateString, calculateColumnPositions, assembleSessionLabel, formatRelativeDate, displaySuffix, } from '../utils/worktreeUtils.js';
 import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from '../utils/gitStatus.js';
 import SearchableList from './SearchableList.js';
 const MAX_BRANCH_NAME_LENGTH = 70;
@@ -63,7 +63,7 @@ function resolveProjectDisplayNames(projects) {
     }
     return displayNames;
 }
-const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDismissError, version, }) => {
+const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAction, error, onDismissError, version, }) => {
     const [projects, setProjects] = useState([]);
     const [recentProjects, setRecentProjects] = useState([]);
     const [loading, setLoading] = useState(true);
@@ -73,6 +73,8 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
     const [sessionEntries, setSessionEntries] = useState([]);
     const [baseSessionWorktrees, setBaseSessionWorktrees] = useState([]);
     const [sessionRefreshKey, setSessionRefreshKey] = useState(0);
+    const [highlightedSession, setHighlightedSession] = useState(null);
+    const [highlightedProject, setHighlightedProject] = useState(null);
     const displayError = error || loadError;
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
         isDisabled: !!displayError,
@@ -220,7 +222,10 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
                     : wt.path.split('/').pop() || 'detached';
                 const branchName = truncateString(fullBranchName, MAX_BRANCH_NAME_LENGTH);
                 const isMain = wt.isMainWorktree ? ' (main)' : '';
-                const baseLabel = `${entry.projectName} :: ${branchName}${isMain}${status}`;
+                const worktreeSessionCount = sessionEntries.filter(e => e.worktree.path === entry.worktree.path &&
+                    e.projectPath === entry.projectPath).length;
+                const sessionSuffix = displaySuffix(entry.session, worktreeSessionCount > 1);
+                const baseLabel = `${entry.projectName} :: ${branchName}${isMain}${sessionSuffix}${status}`;
                 let fileChanges = '';
                 let aheadBehind = '';
                 let parentBranch = '';
@@ -407,6 +412,11 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
             return;
         }
         switch (keyPressed) {
+            case ' ':
+                if (highlightedSession && highlightedProject && onSessionAction) {
+                    onSessionAction(highlightedSession, highlightedProject);
+                }
+                break;
             case 'r':
                 refreshAll();
                 break;
@@ -447,10 +457,20 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
                         if (!item)
                             return;
                         handleSelect(item);
+                    }, onHighlight: raw => {
+                        const item = items.find(i => i.value === raw?.value);
+                        if (item?.type === 'session') {
+                            setHighlightedSession(item.session);
+                            setHighlightedProject(item.project);
+                        }
+                        else {
+                            setHighlightedSession(null);
+                            setHighlightedProject(null);
+                        }
                     }, isFocused: !displayError, limit: limit, initialIndex: selectedIndex }) })), displayError && (_jsx(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red", children: _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", bold: true, children: ["Error: ", displayError] }), _jsx(Text, { color: "gray", dimColor: true, children: "Press any key to dismiss" })] }) })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Status: ", STATUS_ICONS.BUSY, " ", STATUS_LABELS.BUSY, ' ', STATUS_ICONS.WAITING, " ", STATUS_LABELS.WAITING, " ", STATUS_ICONS.IDLE, ' ', STATUS_LABELS.IDLE] }), _jsx(Text, { dimColor: true, children: isSearchMode
                             ? 'Search Mode: Type to filter, Enter to exit search, ESC to exit search'
                             : searchQuery
-                                ? `Filtered: "${searchQuery}" | ↑↓ Navigate Enter Select | /-Search ESC-Clear 0-9 Quick Select R-Refresh Q-Quit`
-                                : 'Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search R-Refresh Q-Quit' })] })] }));
+                                ? `Filtered: "${searchQuery}" | ↑↓ Navigate Enter Select | /-Search ESC-Clear 0-9 Quick Select Space-Session actions (session rows only) R-Refresh Q-Quit`
+                                : 'Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search Space-Session actions (session rows only) R-Refresh Q-Quit' })] })] }));
 };
 export default Dashboard;

package/dist/components/Dashboard.test.js

@@ -1,26 +1,50 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from 'ink-testing-library';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+const capturedHandlers = { inputHandlers: [], onHighlight: null };
+const makeKey = (overrides = {}) => ({
+    upArrow: false,
+    downArrow: false,
+    leftArrow: false,
+    rightArrow: false,
+    pageDown: false,
+    pageUp: false,
+    home: false,
+    end: false,
+    return: false,
+    escape: false,
+    ctrl: false,
+    shift: false,
+    tab: false,
+    backspace: false,
+    delete: false,
+    meta: false,
+    ...overrides,
+});
 // Mock bunTerminal to avoid native module loading issues
 vi.mock('../services/bunTerminal.js', () => ({
     spawn: vi.fn(function () {
         return null;
     }),
 }));
-// Import the actual component code but skip the useInput hook
+// Import the actual component code but capture useInput handlers
 vi.mock('ink', async () => {
     const actual = await vi.importActual('ink');
     return {
         ...actual,
-        useInput: vi.fn(),
+        useInput: vi.fn((handler) => {
+            capturedHandlers.inputHandlers.push(handler);
+        }),
     };
 });
-// Mock SelectInput to render items as simple text
+// Mock SelectInput to render items as simple text and capture onHighlight
 vi.mock('ink-select-input', async () => {
     const React = await vi.importActual('react');
     const { Text, Box } = await vi.importActual('ink');
     return {
-        default: ({ items }) => {
+        default: ({ items, onHighlight, }) => {
+            if (onHighlight)
+                capturedHandlers.onHighlight = onHighlight;
             return React.createElement(Box, { flexDirection: 'column' }, items.map((item, index) => React.createElement(Text, { key: index }, item.label)));
         },
     };
@@ -120,6 +144,8 @@ describe('Dashboard', () => {
     ];
     beforeEach(() => {
         vi.clearAllMocks();
+        capturedHandlers.inputHandlers = [];
+        capturedHandlers.onHighlight = null;
         vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.succeed(mockProjects));
         vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([]);
         vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([]);
@@ -308,6 +334,7 @@ describe('Dashboard', () => {
         const { lastFrame } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
         expect(lastFrame()).toContain('Controls:');
         expect(lastFrame()).toContain('0-9 Quick Select');
+        expect(lastFrame()).toContain('Space-Session actions');
         expect(lastFrame()).toContain('R-Refresh');
         expect(lastFrame()).toContain('Q-Quit');
     });
@@ -345,4 +372,261 @@ describe('Dashboard', () => {
         // shared-lib should appear first (index 0) because it's recent
         expect(frame).toContain('0 ❯ shared-lib');
     });
+    it('should show session name suffix in label when session has a name', async () => {
+        const mockSession = {
+            id: 'session-named',
+            worktreePath: '/projects/my-app/worktrees/feature-auth',
+            sessionNumber: 1,
+            sessionName: 'my-feature',
+            lastActivity: new Date(),
+            isActive: true,
+            stateMutex: {
+                getSnapshot: () => ({
+                    state: 'busy',
+                    backgroundTaskCount: 0,
+                    teamMemberCount: 0,
+                }),
+            },
+        };
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([
+            '/projects/my-app',
+        ]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([
+            mockSession,
+        ]);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: () => Effect.succeed([
+                    {
+                        path: '/projects/my-app/worktrees/feature-auth',
+                        branch: 'feature/auth',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+                getGitRootPath: () => '/projects/my-app',
+            };
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('Active Sessions') ?? false;
+        }, { timeout: 3000 });
+        expect(lastFrame()).toContain('my-app :: feature/auth: my-feature');
+    });
+    it('should show session number suffix when multiple unnamed sessions on same worktree', async () => {
+        const mockSessions = [
+            {
+                id: 'session-1',
+                worktreePath: '/projects/my-app/worktrees/feature-auth',
+                sessionNumber: 1,
+                lastActivity: new Date(),
+                isActive: true,
+                stateMutex: {
+                    getSnapshot: () => ({
+                        state: 'busy',
+                        backgroundTaskCount: 0,
+                        teamMemberCount: 0,
+                    }),
+                },
+            },
+            {
+                id: 'session-2',
+                worktreePath: '/projects/my-app/worktrees/feature-auth',
+                sessionNumber: 2,
+                lastActivity: new Date(),
+                isActive: true,
+                stateMutex: {
+                    getSnapshot: () => ({
+                        state: 'idle',
+                        backgroundTaskCount: 0,
+                        teamMemberCount: 0,
+                    }),
+                },
+            },
+        ];
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([
+            '/projects/my-app',
+        ]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue(mockSessions);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: () => Effect.succeed([
+                    {
+                        path: '/projects/my-app/worktrees/feature-auth',
+                        branch: 'feature/auth',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+                getGitRootPath: () => '/projects/my-app',
+            };
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('Active Sessions') ?? false;
+        }, { timeout: 3000 });
+        const frame = lastFrame();
+        expect(frame).toContain('#1');
+        expect(frame).toContain('#2');
+    });
+    it('should show no session suffix for single unnamed session', async () => {
+        const mockSession = {
+            id: 'session-single',
+            worktreePath: '/projects/my-app/worktrees/feature-auth',
+            sessionNumber: 1,
+            lastActivity: new Date(),
+            isActive: true,
+            stateMutex: {
+                getSnapshot: () => ({
+                    state: 'busy',
+                    backgroundTaskCount: 0,
+                    teamMemberCount: 0,
+                }),
+            },
+        };
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([
+            '/projects/my-app',
+        ]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([
+            mockSession,
+        ]);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: () => Effect.succeed([
+                    {
+                        path: '/projects/my-app/worktrees/feature-auth',
+                        branch: 'feature/auth',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+                getGitRootPath: () => '/projects/my-app',
+            };
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('Active Sessions') ?? false;
+        }, { timeout: 3000 });
+        const frame = lastFrame();
+        expect(frame).toContain('my-app :: feature/auth');
+        expect(frame).not.toContain('feature/auth:');
+        expect(frame).not.toContain('feature/auth #');
+    });
+    it('should call onSessionAction when space is pressed on highlighted session', async () => {
+        const mockOnSessionAction = vi.fn();
+        const mockSession = {
+            id: 'session-action',
+            worktreePath: '/projects/my-app/worktrees/feature-auth',
+            sessionNumber: 1,
+            lastActivity: new Date(),
+            isActive: true,
+            stateMutex: {
+                getSnapshot: () => ({
+                    state: 'busy',
+                    backgroundTaskCount: 0,
+                    teamMemberCount: 0,
+                }),
+            },
+        };
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([
+            '/projects/my-app',
+        ]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([
+            mockSession,
+        ]);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: () => Effect.succeed([
+                    {
+                        path: '/projects/my-app/worktrees/feature-auth',
+                        branch: 'feature/auth',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+                getGitRootPath: () => '/projects/my-app',
+            };
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, onSessionAction: mockOnSessionAction, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, onSessionAction: mockOnSessionAction, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('Active Sessions') ?? false;
+        }, { timeout: 3000 });
+        // Enable the useInput handler (Dashboard guards on process.stdin.setRawMode)
+        const origSetRawMode = process.stdin.setRawMode;
+        process.stdin.setRawMode = vi.fn();
+        // Simulate highlighting a session item
+        expect(capturedHandlers.onHighlight).not.toBeNull();
+        capturedHandlers.onHighlight({
+            value: 'session-session-action',
+            label: 'my-app :: feature/auth',
+        });
+        // Force re-render to flush state update — new useInput handler captures updated closure
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, onSessionAction: mockOnSessionAction, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 50));
+        // Use the latest Dashboard handler (last in array — has updated highlightedSession state)
+        const latestHandler = capturedHandlers.inputHandlers[capturedHandlers.inputHandlers.length - 1];
+        expect(latestHandler).toBeDefined();
+        latestHandler(' ', makeKey());
+        expect(mockOnSessionAction).toHaveBeenCalledWith(expect.objectContaining({ id: 'session-action' }), expect.objectContaining({ path: '/projects/my-app' }));
+        process.stdin.setRawMode = origSetRawMode;
+    });
+    it('should not call onSessionAction when space is pressed with no highlighted session', async () => {
+        const mockOnSessionAction = vi.fn();
+        const mockSession = {
+            id: 'session-noop',
+            worktreePath: '/projects/my-app/worktrees/feature-auth',
+            sessionNumber: 1,
+            lastActivity: new Date(),
+            isActive: true,
+            stateMutex: {
+                getSnapshot: () => ({
+                    state: 'busy',
+                    backgroundTaskCount: 0,
+                    teamMemberCount: 0,
+                }),
+            },
+        };
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([
+            '/projects/my-app',
+        ]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([
+            mockSession,
+        ]);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: () => Effect.succeed([
+                    {
+                        path: '/projects/my-app/worktrees/feature-auth',
+                        branch: 'feature/auth',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+                getGitRootPath: () => '/projects/my-app',
+            };
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, onSessionAction: mockOnSessionAction, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, onSessionAction: mockOnSessionAction, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('Active Sessions') ?? false;
+        }, { timeout: 3000 });
+        // Enable the useInput handler (Dashboard guards on process.stdin.setRawMode)
+        const origSetRawMode = process.stdin.setRawMode;
+        process.stdin.setRawMode = vi.fn();
+        // Do NOT call onHighlight — highlightedSession stays null
+        const dashboardHandler = capturedHandlers.inputHandlers.find(handler => handler !== capturedHandlers.inputHandlers[0]);
+        expect(dashboardHandler).toBeDefined();
+        dashboardHandler(' ', makeKey());
+        expect(mockOnSessionAction).not.toHaveBeenCalled();
+        process.stdin.setRawMode = origSetRawMode;
+    });
 });

package/dist/services/worktreeService.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from 'effect';
-import { Worktree, CreateWorktreeResult, MergeConfig } from '../types/index.js';
+import { Worktree, CreateWorktreeResult, AmbiguousBranchError, MergeConfig } from '../types/index.js';
 import { GitError, FileSystemError, ProcessError } from '../types/errors.js';
 /**
  * WorktreeService - Git worktree management with Effect-based error handling
@@ -53,6 +53,7 @@ export declare class WorktreeService {
      * @throws {AmbiguousBranchError} When branch exists in multiple remotes
      */
     private resolveBranchReference;
+    private resolveBranchReferenceEffect;
     /**
      * SYNCHRONOUS HELPER: Gets all git remotes for this repository.
      *
@@ -323,7 +324,7 @@ export declare class WorktreeService {
      * @throws {GitError} When git worktree add command fails
      * @throws {FileSystemError} When session data copy fails
      */
-    createWorktreeEffect(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): Effect.Effect<CreateWorktreeResult, GitError | FileSystemError | ProcessError, never>;
+    createWorktreeEffect(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): Effect.Effect<CreateWorktreeResult, GitError | FileSystemError | ProcessError | AmbiguousBranchError, never>;
     /**
      * Effect-based deleteWorktree operation
      * May fail with GitError

package/dist/services/worktreeService.js

@@ -162,6 +162,18 @@ export class WorktreeService {
             return branchName;
         }
     }
+    resolveBranchReferenceEffect(branchName) {
+        return Effect.try({
+            try: () => this.resolveBranchReference(branchName),
+            catch: error => {
+                if (error instanceof AmbiguousBranchError)
+                    return error;
+                // resolveBranchReference only re-throws AmbiguousBranchError; all
+                // other errors are swallowed internally. This path is unreachable.
+                throw error;
+            },
+        });
+    }
     /**
      * SYNCHRONOUS HELPER: Gets all git remotes for this repository.
      *
@@ -812,12 +824,18 @@ export class WorktreeService {
             if (localBranchExists) {
                 command = `git worktree add "${resolvedPath}" "${branch}"`;
             }
+            else if (baseBranch.endsWith(`/${branch}`)) {
+                // baseBranch is already a remote-tracking ref for branch
+                // (e.g. "origin/feature/x" after the user resolved an ambiguity).
+                // Use it directly to avoid re-triggering AmbiguousBranchError.
+                command = `git worktree add -b "${branch}" "${resolvedPath}" "${baseBranch}"`;
+            }
             else {
-                const resolvedRef = self.resolveBranchReference(branch);
+                const resolvedRef = yield* self.resolveBranchReferenceEffect(branch);
                 const isRemoteBranch = resolvedRef !== branch;
                 const startPoint = isRemoteBranch
                     ? resolvedRef
-                    : self.resolveBranchReference(baseBranch);
+                    : yield* self.resolveBranchReferenceEffect(baseBranch);
                 command = `git worktree add -b "${branch}" "${resolvedPath}" "${startPoint}"`;
             }
             // Execute the worktree creation command

package/dist/services/worktreeService.test.js

@@ -5,6 +5,7 @@ import { existsSync, statSync } from 'fs';
 import { configReader } from './config/configReader.js';
 import { Effect } from 'effect';
 import { GitError, ProcessError } from '../types/errors.js';
+import { AmbiguousBranchError } from '../types/index.js';
 // Mock child_process module
 vi.mock('child_process');
 // Mock fs module
@@ -369,6 +370,61 @@ origin/feature/test
             expect(result).toBe('foo/bar-xyz');
         });
     });
+    describe('resolveBranchReferenceEffect', () => {
+        it('should succeed with remote ref when single remote has the branch', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    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 '';
+                    }
+                    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 effect = service.resolveBranchReferenceEffect('foo/bar-xyz');
+            const result = await Effect.runPromise(Effect.either(effect));
+            expect(result._tag).toBe('Right');
+            if (result._tag === 'Right') {
+                expect(result.right).toBe('origin/foo/bar-xyz');
+            }
+        });
+        it('should fail with AmbiguousBranchError (not Die) when multiple remotes have the branch', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    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 '';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const effect = service.resolveBranchReferenceEffect('foo/bar-xyz');
+            const result = await Effect.runPromise(Effect.either(effect));
+            expect(result._tag).toBe('Left');
+            if (result._tag === 'Left') {
+                expect(result.left).toBeInstanceOf(AmbiguousBranchError);
+                expect(result.left._tag).toBe('AmbiguousBranchError');
+                expect(result.left.branchName).toBe('foo/bar-xyz');
+                expect(result.left.matches).toHaveLength(2);
+            }
+        });
+    });
     describe('hasClaudeDirectoryInBranchEffect', () => {
         it('should return Effect with true when .claude directory exists in branch worktree', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
@@ -695,6 +751,65 @@ 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 () => {
+            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('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 branch
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.createWorktreeEffect('/path/to/worktree', 'feature/feed-mention', 'main');
+            const result = await Effect.runPromise(Effect.either(effect));
+            expect(result._tag).toBe('Left');
+            if (result._tag === 'Left') {
+                expect(result.left).toBeInstanceOf(AmbiguousBranchError);
+                expect(result.left._tag).toBe('AmbiguousBranchError');
+                expect(result.left.branchName).toBe('feature/feed-mention');
+                expect(result.left.matches).toHaveLength(2);
+                expect(result.left.matches.map(m => m.remote)).toEqual(['origin', 'kbwo-fork']);
+            }
+        });
+        it('should succeed when baseBranch is already a resolved remote ref for branch (retry after disambiguation)', 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';
+                    }
+                    // No local branch
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/')) {
+                        throw new Error('Branch not found');
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                }
+                return '';
+            });
+            // Simulate the retry call: user selected "origin/feature/feed-mention",
+            // which is passed as baseBranch.
+            const effect = service.createWorktreeEffect('/path/to/worktree', 'feature/feed-mention', 'origin/feature/feed-mention');
+            const result = await Effect.runPromise(Effect.either(effect));
+            expect(result._tag).toBe('Right');
+            // Should use baseBranch directly as startPoint without calling show-ref
+            const worktreeAddCmd = executedCommands.find(c => c.includes('git worktree add'));
+            expect(worktreeAddCmd).toContain('-b "feature/feed-mention"');
+            expect(worktreeAddCmd).toContain('"origin/feature/feed-mention"');
+            // show-ref for remotes must NOT be called (no re-resolution)
+            expect(executedCommands.some(c => c.includes('show-ref') && c.includes('refs/remotes/'))).toBe(false);
+        });
         it('should return Effect that fails with GitError on git command failure', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {

package/dist/types/index.d.ts

@@ -4,7 +4,8 @@ import type { SerializeAddon } from '@xterm/addon-serialize';
 import { GitStatus } from '../utils/gitStatus.js';
 import { Mutex, SessionStateData } from '../utils/mutex.js';
 import type { StateDetector } from '../services/stateDetector/types.js';
-import type { ProcessError } from './errors.js';
+import type { Effect } from 'effect';
+import type { GitError, FileSystemError, ProcessError } from './errors.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input' | 'pending_auto_approval';
 export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline' | 'opencode' | 'kimi';
@@ -249,16 +250,17 @@ export interface RemoteBranchMatch {
     fullRef: string;
 }
 export declare class AmbiguousBranchError extends Error {
+    readonly _tag: "AmbiguousBranchError";
     branchName: string;
     matches: RemoteBranchMatch[];
     constructor(branchName: string, matches: RemoteBranchMatch[]);
 }
 export interface IWorktreeService {
-    getWorktreesEffect(): import('effect').Effect.Effect<Worktree[], import('../types/errors.js').GitError, never>;
+    getWorktreesEffect(): Effect.Effect<Worktree[], GitError, never>;
     getGitRootPath(): string;
-    createWorktreeEffect(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): import('effect').Effect.Effect<CreateWorktreeResult, import('../types/errors.js').GitError | import('../types/errors.js').FileSystemError | import('../types/errors.js').ProcessError, never>;
+    createWorktreeEffect(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): Effect.Effect<CreateWorktreeResult, GitError | FileSystemError | ProcessError | AmbiguousBranchError, never>;
     deleteWorktreeEffect(worktreePath: string, options?: {
         deleteBranch?: boolean;
-    }): import('effect').Effect.Effect<void, import('../types/errors.js').GitError, never>;
-    mergeWorktreeEffect(sourceBranch: string, targetBranch: string, operation?: 'merge' | 'rebase', mergeConfig?: MergeConfig): import('effect').Effect.Effect<void, import('../types/errors.js').GitError, never>;
+    }): Effect.Effect<void, GitError, never>;
+    mergeWorktreeEffect(sourceBranch: string, targetBranch: string, operation?: 'merge' | 'rebase', mergeConfig?: MergeConfig): Effect.Effect<void, GitError, never>;
 }

package/dist/types/index.js

@@ -3,6 +3,7 @@ export const DEFAULT_SHORTCUTS = {
     cancel: { key: 'escape' },
 };
 export class AmbiguousBranchError extends Error {
+    _tag = 'AmbiguousBranchError';
     branchName;
     matches;
     constructor(branchName, matches) {

package/dist/utils/worktreeUtils.d.ts

@@ -29,6 +29,7 @@ export declare function extractBranchParts(branchName: string): {
     prefix?: string;
     name: string;
 };
+export declare function displaySuffix(session: Session, multipleForWorktree: boolean): string;
 /**
  * Prepares session items for display.
  * Supports multiple sessions per worktree.

package/dist/utils/worktreeUtils.js

@@ -122,7 +122,7 @@ function indexSessionsByWorktree(sessions) {
     }
     return { byWorktreePath, maxAccessAt };
 }
-function displaySuffix(session, multipleForWorktree) {
+export function displaySuffix(session, multipleForWorktree) {
     if (multipleForWorktree) {
         return session.sessionName
             ? `: ${session.sessionName}`

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.1.18",
+	"version": "4.1.20",
 	"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.1.18",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.18",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.18",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.1.18",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.1.18"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.20",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.20",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.20",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.1.20",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.1.20"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",