ccmanager 3.12.6 → 4.0.0

package/dist/components/Menu.js

@@ -6,7 +6,7 @@ import { Effect } from 'effect';
 import { SessionManager } from '../services/sessionManager.js';
 import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, } from '../constants/statusIcons.js';
 import { useGitStatus } from '../hooks/useGitStatus.js';
-import { prepareWorktreeItems, calculateColumnPositions, assembleWorktreeLabel, } from '../utils/worktreeUtils.js';
+import { prepareSessionItems, calculateColumnPositions, assembleSessionLabel, } from '../utils/worktreeUtils.js';
 import { projectManager } from '../services/projectManager.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
@@ -29,7 +29,7 @@ const createSeparatorWithText = (text, totalWidth = 35) => {
 const formatGitError = (error) => {
     return `Git command failed: ${error.command} (exit ${error.exitCode})\n${error.stderr}`;
 };
-const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecentProject, error, onDismissError, projectName, multiProject = false, version, }) => {
+const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentProject, error, onDismissError, projectName, multiProject = false, version, }) => {
     const [baseWorktrees, setBaseWorktrees] = useState([]);
     const [defaultBranch, setDefaultBranch] = useState(null);
     const [loadError, setLoadError] = useState(null);
@@ -38,6 +38,7 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
     const [items, setItems] = useState([]);
     const [recentProjects, setRecentProjects] = useState([]);
     const [highlightedWorktreePath, setHighlightedWorktreePath] = useState(null);
+    const [highlightedSession, setHighlightedSession] = useState(undefined);
     const [autoApprovalToggleCounter, setAutoApprovalToggleCounter] = useState(0);
     // Use the search mode hook
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
@@ -53,9 +54,7 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
         let cancelled = false;
         // Load worktrees and default branch using Effect composition
         // Chain getWorktreesEffect and getDefaultBranchEffect using Effect.flatMap
-        const loadWorktreesAndBranch = Effect.flatMap(worktreeService.getWorktreesEffect({
-            sortByLastSession: worktreeConfig.sortByLastSession,
-        }), worktrees => Effect.map(worktreeService.getDefaultBranchEffect(), defaultBranch => ({
+        const loadWorktreesAndBranch = Effect.flatMap(worktreeService.getWorktreesEffect(), worktrees => Effect.map(worktreeService.getDefaultBranchEffect(), defaultBranch => ({
             worktrees,
             defaultBranch,
         })));
@@ -118,15 +117,12 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             sessionManager.off('sessionDestroyed', handleSessionChange);
             sessionManager.off('sessionStateChanged', handleSessionChange);
         };
-    }, [
-        sessionManager,
-        worktreeService,
-        multiProject,
-        worktreeConfig.sortByLastSession,
-    ]);
+    }, [sessionManager, worktreeService, multiProject]);
     useEffect(() => {
         // Prepare worktree items and calculate layout
-        const items = prepareWorktreeItems(worktrees, sessions);
+        const items = prepareSessionItems(worktrees, sessions, {
+            sortByLastSession: worktreeConfig.sortByLastSession,
+        });
         const columnPositions = calculateColumnPositions(items);
         // Filter worktrees based on search query
         const filteredWorktrees = filterWorktreesByQuery(items.map(item => item.worktree), searchQuery);
@@ -134,18 +130,23 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
         const filteredItems = items.filter(item => filteredWorktreeSet.has(item.worktree));
         // Build menu items with proper alignment
         const menuItems = filteredItems.map((item, index) => {
-            const baseLabel = assembleWorktreeLabel(item, columnPositions);
+            const baseLabel = assembleSessionLabel(item, columnPositions);
             const aaDisabled = configReader.isAutoApprovalEnabled() &&
                 sessionManager.isAutoApprovalDisabledForWorktree(item.worktree.path);
             const label = baseLabel + (aaDisabled ? ' [Auto Approval Off]' : '');
             // Only show numbers for worktrees (0-9) when not in search mode
             // Use fixed-width prefix to prevent flicker at scroll boundary
             const numberPrefix = !isSearchMode && index < 10 ? `${index} ❯ ` : '  ❯ ';
+            // Use session id for value if present, otherwise worktree path
+            const value = item.session
+                ? `session:${item.session.id}`
+                : item.worktree.path;
             return {
                 type: 'worktree',
                 label: numberPrefix + label,
-                value: item.worktree.path,
+                value,
                 worktree: item.worktree,
+                session: item.session,
             };
         });
         // Filter recent projects based on search query
@@ -257,14 +258,18 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
         }
         setItems(menuItems);
         // Ensure highlighted worktree path is valid for hotkey support
-        // (e.g., on initial render or when returning from a session view)
         setHighlightedWorktreePath(prev => {
             if (prev &&
-                menuItems.some(item => item.type === 'worktree' && item.value === prev)) {
+                menuItems.some(item => item.type === 'worktree' && item.worktree.path === prev)) {
                 return prev;
             }
             const first = menuItems.find(item => item.type === 'worktree');
-            return first && first.type === 'worktree' ? first.worktree.path : null;
+            if (first && first.type === 'worktree') {
+                setHighlightedSession(first.session);
+                return first.worktree.path;
+            }
+            setHighlightedSession(undefined);
+            return null;
         });
     }, [
         worktrees,
@@ -277,6 +282,7 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
         isSearchMode,
         autoApprovalToggleCounter,
         sessionManager,
+        worktreeConfig.sortByLastSession,
     ]);
     // Handle hotkeys
     useInput((input, _key) => {
@@ -307,7 +313,11 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             const projectItems = items.filter(item => item.type === 'project');
             // Check if it's a worktree
             if (index < worktreeItems.length && worktreeItems[index]) {
-                onSelectWorktree(worktreeItems[index].worktree);
+                onMenuAction({
+                    type: 'selectWorktree',
+                    worktree: worktreeItems[index].worktree,
+                    session: worktreeItems[index].session,
+                });
                 return;
             }
             // Check if it's a recent project (when worktrees < 10)
@@ -329,86 +339,49 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
                     setAutoApprovalToggleCounter(c => c + 1);
                 }
                 break;
+            case ' ':
+                // Open session actions for highlighted session
+                if (highlightedSession && highlightedWorktreePath) {
+                    onMenuAction({
+                        type: 'sessionActions',
+                        session: highlightedSession,
+                        worktreePath: highlightedWorktreePath,
+                    });
+                }
+                break;
             case 'n':
-                // Trigger new worktree action
-                onSelectWorktree({
-                    path: '',
-                    branch: '',
-                    isMainWorktree: false,
-                    hasSession: false,
-                });
+                onMenuAction({ type: 'newWorktree' });
                 break;
             case 'm':
-                // Trigger merge worktree action
-                onSelectWorktree({
-                    path: 'MERGE_WORKTREE',
-                    branch: '',
-                    isMainWorktree: false,
-                    hasSession: false,
-                });
+                onMenuAction({ type: 'mergeWorktree' });
                 break;
             case 'd':
-                // Trigger delete worktree action
-                onSelectWorktree({
-                    path: 'DELETE_WORKTREE',
-                    branch: '',
-                    isMainWorktree: false,
-                    hasSession: false,
-                });
+                onMenuAction({ type: 'deleteWorktree' });
                 break;
             case 'p':
                 // Trigger project configuration action (only in single-project mode)
                 if (!multiProject) {
-                    onSelectWorktree({
-                        path: 'CONFIGURATION_PROJECT',
-                        branch: '',
-                        isMainWorktree: false,
-                        hasSession: false,
-                    });
+                    onMenuAction({ type: 'configuration', scope: 'project' });
                 }
                 break;
             case 'c':
-                // Trigger configuration action
-                if (multiProject) {
-                    // In multi-project mode, 'c' opens global configuration (backward compatible)
-                    onSelectWorktree({
-                        path: 'CONFIGURATION',
-                        branch: '',
-                        isMainWorktree: false,
-                        hasSession: false,
-                    });
-                }
-                else {
-                    // In single-project mode, 'c' opens global configuration
-                    onSelectWorktree({
-                        path: 'CONFIGURATION_GLOBAL',
-                        branch: '',
-                        isMainWorktree: false,
-                        hasSession: false,
-                    });
-                }
+                onMenuAction({ type: 'configuration', scope: 'global' });
                 break;
             case 'b':
                 // In multi-project mode, go back to project list
                 if (projectName) {
-                    onSelectWorktree({
-                        path: 'EXIT_APPLICATION',
-                        branch: '',
-                        isMainWorktree: false,
-                        hasSession: false,
-                    });
+                    onMenuAction({ type: 'exit' });
                 }
                 break;
-            case 'q':
             case 'x':
+                if (!projectName) {
+                    onMenuAction({ type: 'exit' });
+                }
+                break;
+            case 'q':
                 // Trigger exit action (only in single-project mode)
                 if (!projectName) {
-                    onSelectWorktree({
-                        path: 'EXIT_APPLICATION',
-                        branch: '',
-                        isMainWorktree: false,
-                        hasSession: false,
-                    });
+                    onMenuAction({ type: 'exit' });
                 }
                 break;
         }
@@ -418,7 +391,6 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             // Do nothing for separators and headers
         }
         else if (item.type === 'project') {
-            // Handle recent project selection
             if (onSelectRecentProject) {
                 const project = {
                     path: item.recentProject.path,
@@ -430,79 +402,32 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             }
         }
         else if (item.value === 'new-worktree') {
-            // Handle in parent component
-            onSelectWorktree({
-                path: '',
-                branch: '',
-                isMainWorktree: false,
-                hasSession: false,
-            });
+            onMenuAction({ type: 'newWorktree' });
         }
         else if (item.value === 'merge-worktree') {
-            // Handle in parent component - use special marker
-            onSelectWorktree({
-                path: 'MERGE_WORKTREE',
-                branch: '',
-                isMainWorktree: false,
-                hasSession: false,
-            });
+            onMenuAction({ type: 'mergeWorktree' });
         }
         else if (item.value === 'delete-worktree') {
-            // Handle in parent component - use special marker
-            onSelectWorktree({
-                path: 'DELETE_WORKTREE',
-                branch: '',
-                isMainWorktree: false,
-                hasSession: false,
-            });
+            onMenuAction({ type: 'deleteWorktree' });
         }
         else if (item.value === 'configuration') {
-            // Handle in parent component - use special marker (backward compatible for multi-project mode)
-            onSelectWorktree({
-                path: 'CONFIGURATION',
-                branch: '',
-                isMainWorktree: false,
-                hasSession: false,
-            });
+            onMenuAction({ type: 'configuration', scope: 'global' });
         }
         else if (item.value === 'configuration-project') {
-            // Handle in parent component - use special marker for project config
-            onSelectWorktree({
-                path: 'CONFIGURATION_PROJECT',
-                branch: '',
-                isMainWorktree: false,
-                hasSession: false,
-            });
+            onMenuAction({ type: 'configuration', scope: 'project' });
         }
         else if (item.value === 'configuration-global') {
-            // Handle in parent component - use special marker for global config
-            onSelectWorktree({
-                path: 'CONFIGURATION_GLOBAL',
-                branch: '',
-                isMainWorktree: false,
-                hasSession: false,
-            });
+            onMenuAction({ type: 'configuration', scope: 'global' });
         }
-        else if (item.value === 'exit') {
-            // Handle in parent component - use special marker
-            onSelectWorktree({
-                path: 'EXIT_APPLICATION',
-                branch: '',
-                isMainWorktree: false,
-                hasSession: false,
-            });
-        }
-        else if (item.value === 'back-to-projects') {
-            // Handle in parent component - use special marker
-            onSelectWorktree({
-                path: 'EXIT_APPLICATION',
-                branch: '',
-                isMainWorktree: false,
-                hasSession: false,
-            });
+        else if (item.value === 'exit' || item.value === 'back-to-projects') {
+            onMenuAction({ type: 'exit' });
         }
         else if (item.type === 'worktree') {
-            onSelectWorktree(item.worktree);
+            onMenuAction({
+                type: 'selectWorktree',
+                worktree: item.worktree,
+                session: item.session,
+            });
         }
     };
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, color: "green", children: ["CCManager - Claude Code Worktree Manager v", version] }), projectName && (_jsx(Text, { bold: true, color: "green", children: projectName }))] }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Select a worktree to start or resume a Claude Code session:" }) }), _jsx(SearchableList, { isSearchMode: isSearchMode, searchQuery: searchQuery, onSearchQueryChange: setSearchQuery, selectedIndex: selectedIndex, items: items, limit: limit, placeholder: "Type to filter worktrees...", noMatchMessage: "No worktrees match your search", children: _jsx(SelectInput, { items: items, onSelect: item => handleSelect(item), onHighlight: item => {
@@ -514,11 +439,12 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
                         const menuItem = item;
                         if (menuItem.type === 'worktree') {
                             setHighlightedWorktreePath(menuItem.worktree.path);
+                            setHighlightedSession(menuItem.session);
                         }
                     }, isFocused: !error, initialIndex: selectedIndex, limit: limit }) }), (error || loadError) && (_jsx(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red", children: _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", bold: true, children: ["Error: ", error || loadError] }), _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, configReader.isAutoApprovalEnabled() && (_jsxs(_Fragment, { children: [' | ', _jsx(Text, { color: "green", children: "Auto Approval Enabled" })] }))] }), _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 N-New M-Merge D-Delete ${configReader.isAutoApprovalEnabled() ? 'A-AutoApproval ' : ''}${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}`
-                                : `Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search N-New M-Merge D-Delete ${configReader.isAutoApprovalEnabled() ? 'A-AutoApproval ' : ''}${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}` })] })] }));
+                                ? `Filtered: "${searchQuery}" | ↑↓ Navigate Enter Select | /-Search ESC-Clear 0-9 Quick Select Space-Session actions (session rows only) N-New M-Merge D-Delete ${configReader.isAutoApprovalEnabled() ? 'A-AutoApproval ' : ''}${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}`
+                                : `Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search Space-Session actions (session rows only) N-New M-Merge D-Delete ${configReader.isAutoApprovalEnabled() ? 'A-AutoApproval ' : ''}${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}` })] })] }));
 };
 export default Menu;

package/dist/components/Menu.recent-projects.test.js

@@ -108,7 +108,7 @@ describe('Menu - Recent Projects', () => {
         vi.mocked(projectManager.getRecentProjects).mockReturnValue([
             { path: '/project1', name: 'Project 1', lastAccessed: 1000 },
         ]);
-        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), multiProject: false, version: "test" }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onMenuAction: vi.fn(), multiProject: false, version: "test" }));
         const output = lastFrame();
         expect(output).not.toContain('─ Recent ─');
         expect(output).not.toContain('Project 1');
@@ -129,9 +129,9 @@ describe('Menu - Recent Projects', () => {
             teamMembers: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
-        const { lastFrame, rerender } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
+        const { lastFrame, rerender } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onMenuAction: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         // Force a rerender to ensure all effects have run
-        rerender(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
+        rerender(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onMenuAction: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         await vi.waitFor(() => {
             const output = lastFrame();
             expect(output).toContain('─ Recent ─');
@@ -141,7 +141,7 @@ describe('Menu - Recent Projects', () => {
     });
     it('should not show recent projects section when no recent projects', () => {
         vi.mocked(projectManager.getRecentProjects).mockReturnValue([]);
-        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onMenuAction: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         const output = lastFrame();
         expect(output).not.toContain('─ Recent ─');
     });
@@ -163,7 +163,7 @@ describe('Menu - Recent Projects', () => {
             teamMembers: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
-        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onMenuAction: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         await vi.waitFor(() => {
             const output = lastFrame();
             expect(output).toContain('─ Recent ─');
@@ -183,9 +183,9 @@ describe('Menu - Recent Projects', () => {
             ...mockWorktreeService,
             getGitRootPath: vi.fn().mockReturnValue('/current/project'),
         };
-        const { lastFrame, rerender } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: worktreeServiceWithGitRoot, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
+        const { lastFrame, rerender } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: worktreeServiceWithGitRoot, onMenuAction: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         // Force a rerender to ensure all effects have run
-        rerender(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: worktreeServiceWithGitRoot, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
+        rerender(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: worktreeServiceWithGitRoot, onMenuAction: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         await vi.waitFor(() => {
             const output = lastFrame();
             expect(output).toContain('─ Recent ─');
@@ -204,7 +204,7 @@ describe('Menu - Recent Projects', () => {
         ]);
         // Mock getGitRootPath to return the current project path
         vi.mocked(mockWorktreeService.getGitRootPath).mockReturnValue('/current/project');
-        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onMenuAction: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         const output = lastFrame();
         expect(output).not.toContain('─ Recent ─');
         expect(output).not.toContain('Current Project');

package/dist/components/Menu.test.js

@@ -78,7 +78,7 @@ describe('Menu component Effect-based error handling', () => {
     it('should handle GitError from getWorktreesEffect and display error message', async () => {
         const { Effect } = await import('effect');
         const { GitError } = await import('../types/errors.js');
-        const onSelectWorktree = vi.fn();
+        const onMenuAction = vi.fn();
         const onDismissError = vi.fn();
         // Mock getWorktreesEffect to return a failing Effect
         const gitError = new GitError({
@@ -88,7 +88,7 @@ describe('Menu component Effect-based error handling', () => {
             stdout: '',
         });
         vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.fail(gitError));
-        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onDismissError: onDismissError, version: "test" }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: onMenuAction, onDismissError: onDismissError, version: "test" }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
@@ -99,7 +99,7 @@ describe('Menu component Effect-based error handling', () => {
     });
     it('should successfully load worktrees using getWorktreesEffect', async () => {
         const { Effect } = await import('effect');
-        const onSelectWorktree = vi.fn();
+        const onMenuAction = vi.fn();
         const mockWorktrees = [
             {
                 path: '/test/main',
@@ -118,7 +118,7 @@ describe('Menu component Effect-based error handling', () => {
         vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.succeed(mockWorktrees));
         // Mock getDefaultBranchEffect to return successful Effect
         vi.spyOn(worktreeService, 'getDefaultBranchEffect').mockReturnValue(Effect.succeed('main'));
-        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, version: "test" }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: onMenuAction, version: "test" }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
@@ -129,7 +129,7 @@ describe('Menu component Effect-based error handling', () => {
     it('should handle GitError from getDefaultBranchEffect and display error message', async () => {
         const { Effect } = await import('effect');
         const { GitError } = await import('../types/errors.js');
-        const onSelectWorktree = vi.fn();
+        const onMenuAction = vi.fn();
         const onDismissError = vi.fn();
         const mockWorktrees = [
             {
@@ -149,7 +149,7 @@ describe('Menu component Effect-based error handling', () => {
             stdout: '',
         });
         vi.spyOn(worktreeService, 'getDefaultBranchEffect').mockReturnValue(Effect.fail(gitError));
-        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onDismissError: onDismissError, version: "test" }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: onMenuAction, onDismissError: onDismissError, version: "test" }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
@@ -160,7 +160,7 @@ describe('Menu component Effect-based error handling', () => {
     });
     it('should use Effect composition to load worktrees and default branch together', async () => {
         const { Effect } = await import('effect');
-        const onSelectWorktree = vi.fn();
+        const onMenuAction = vi.fn();
         const mockWorktrees = [
             {
                 path: '/test/main',
@@ -176,7 +176,7 @@ describe('Menu component Effect-based error handling', () => {
         const getDefaultBranchSpy = vi
             .spyOn(worktreeService, 'getDefaultBranchEffect')
             .mockReturnValue(Effect.succeed('main'));
-        render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, version: "test" }));
+        render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: onMenuAction, version: "test" }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 100));
         // Verify both Effect-based methods were called (Effect composition)
@@ -203,9 +203,9 @@ describe('Menu component rendering', () => {
         vi.restoreAllMocks();
     });
     it('should not render duplicate title when re-rendered with new key', async () => {
-        const onSelectWorktree = vi.fn();
+        const onMenuAction = vi.fn();
         // First render
-        const { unmount, lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, version: "test" }, 1));
+        const { unmount, lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: onMenuAction, version: "test" }, 1));
         // Wait for async operations
         await new Promise(resolve => setTimeout(resolve, 100));
         const firstRenderOutput = lastFrame();
@@ -215,7 +215,7 @@ describe('Menu component rendering', () => {
         expect(titleCount).toBe(1);
         // Unmount and re-render with new key
         unmount();
-        const { lastFrame: lastFrame2 } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, version: "test" }, 2));
+        const { lastFrame: lastFrame2 } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: onMenuAction, version: "test" }, 2));
         await new Promise(resolve => setTimeout(resolve, 100));
         const secondRenderOutput = lastFrame2();
         const titleCount2 = (secondRenderOutput?.match(/CCManager - Claude Code Worktree Manager/g) ||
@@ -223,8 +223,8 @@ describe('Menu component rendering', () => {
         expect(titleCount2).toBe(1);
     });
     it('should render title and description only once', async () => {
-        const onSelectWorktree = vi.fn();
-        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, version: "test" }));
+        const onMenuAction = vi.fn();
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: onMenuAction, version: "test" }));
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
         // Check title appears only once
@@ -236,7 +236,7 @@ describe('Menu component rendering', () => {
     });
     it('should display number shortcuts for recent projects when worktrees < 10', async () => {
         const { Effect } = await import('effect');
-        const onSelectWorktree = vi.fn();
+        const onMenuAction = vi.fn();
         const onSelectRecentProject = vi.fn();
         // Setup: 3 worktrees
         const mockWorktrees = [
@@ -280,7 +280,7 @@ describe('Menu component rendering', () => {
             teamMembers: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
-        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true, version: "test" }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: onMenuAction, onSelectRecentProject: onSelectRecentProject, multiProject: true, version: "test" }));
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
         // Check that worktrees have numbers 0-2
@@ -294,7 +294,7 @@ describe('Menu component rendering', () => {
     });
     it('should not display number shortcuts for recent projects when worktrees >= 10', async () => {
         const { Effect } = await import('effect');
-        const onSelectWorktree = vi.fn();
+        const onMenuAction = vi.fn();
         const onSelectRecentProject = vi.fn();
         // Setup: 10 worktrees
         const mockWorktrees = Array.from({ length: 10 }, (_, i) => ({
@@ -323,7 +323,7 @@ describe('Menu component rendering', () => {
             teamMembers: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
-        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true, version: "test" }));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: onMenuAction, onSelectRecentProject: onSelectRecentProject, multiProject: true, version: "test" }));
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();
         // Check that recent projects don't have numbers (just ❯ prefix)

package/dist/components/Session.js

@@ -76,7 +76,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         // Listen for restore event first
         sessionManager.on('sessionRestore', handleSessionRestore);
         // Mark session as active (this will trigger the restore event)
-        sessionManager.setSessionActive(session.worktreePath, true);
+        sessionManager.setSessionActive(session.id, true);
         // Immediately resize the PTY and terminal to current dimensions
         // This fixes rendering issues when terminal width changed while in menu
         // https://github.com/kbwo/ccmanager/issues/2
@@ -142,7 +142,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
                 return;
             }
             if (session.stateMutex.getSnapshot().state === 'pending_auto_approval') {
-                sessionManager.cancelAutoApproval(session.worktreePath, 'User input received during auto-approval');
+                sessionManager.cancelAutoApproval(session.id, 'User input received during auto-approval');
             }
             // Pass all other input directly to the PTY
             session.process.write(data);
@@ -156,7 +156,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
                 resetTerminalInputModes();
             }
             // Mark session as inactive
-            sessionManager.setSessionActive(session.worktreePath, false);
+            sessionManager.setSessionActive(session.id, false);
             // Remove event listeners
             sessionManager.off('sessionRestore', handleSessionRestore);
             sessionManager.off('sessionData', handleSessionData);

package/dist/components/SessionActions.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export type SessionActionType = 'newSession' | 'rename' | 'kill';
+interface SessionActionsProps {
+    sessionLabel: string;
+    onSelect: (action: SessionActionType) => void;
+    onCancel: () => void;
+}
+declare const SessionActions: React.FC<SessionActionsProps>;
+export default SessionActions;

package/dist/components/SessionActions.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+const items = [
+    { label: 'S  New session in same directory', value: 'newSession' },
+    { label: 'R  Rename this session', value: 'rename' },
+    { label: 'X  Close session', value: 'kill' },
+];
+const SessionActions = ({ sessionLabel, onSelect, onCancel, }) => {
+    useInput((input, key) => {
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        switch (input.toLowerCase()) {
+            case 's':
+                onSelect('newSession');
+                break;
+            case 'r':
+                onSelect('rename');
+                break;
+            case 'x':
+                onSelect('kill');
+                break;
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Session Actions" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: sessionLabel }) }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: items, onSelect: item => onSelect(item.value) }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "S/R/X or arrow keys + Enter | Escape to cancel" }) })] }));
+};
+export default SessionActions;

package/dist/components/SessionRename.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface SessionRenameProps {
+    currentName?: string;
+    onRename: (name?: string) => void;
+    onCancel: () => void;
+}
+declare const SessionRename: React.FC<SessionRenameProps>;
+export default SessionRename;

package/dist/components/SessionRename.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+const SessionRename = ({ currentName, onRename, onCancel, }) => {
+    const [name, setName] = useState(currentName || '');
+    useInput((_input, key) => {
+        if (key.escape) {
+            onCancel();
+        }
+    });
+    const handleSubmit = () => {
+        const trimmed = name.trim();
+        onRename(trimmed || undefined);
+    };
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Rename Session" }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: "Name: " }), _jsx(TextInput, { value: name, onChange: setName, onSubmit: handleSubmit, placeholder: "Enter session name (empty to clear)" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter to confirm, Escape to cancel" }) })] }));
+};
+export default SessionRename;