ccmanager 4.3.0 → 4.3.2

package/README.md

@@ -15,6 +15,7 @@ https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 - Visual status indicators for session states (busy, waiting, idle)
 - Create, merge, and delete worktrees from within the app
 - **Copy Claude Code session data** between worktrees to maintain conversation context
+- **`.worktreeinclude` support**: carry gitignored project files (`.env`, local certs) into newly created worktrees
 - Configurable keyboard shortcuts
 - Command presets with automatic fallback support
 - Configurable state detection strategies for different CLI tools
@@ -209,6 +210,17 @@ The default choice (copy or start fresh) will be pre-selected when creating new
 - **Context Preservation**: Maintain long conversations across multiple development branches
 
 
+## Copying Gitignored Files into New Worktrees
+
+A new Git worktree contains only tracked files, so gitignored files a project needs in order to run — `.env`, local certificates, generated local config — do not come along. If the repository root has a `.worktreeinclude` file (gitignore syntax) listing those files, CCManager copies them into every worktree it creates.
+
+- **Shared convention**: same file name and semantics as Claude Code, Conductor, OpenAI Codex, and `git-worktreeinclude`, so an existing `.worktreeinclude` works with CCManager unchanged
+- **No configuration**: the copy runs whenever a `.worktreeinclude` file exists
+- **Safe by construction**: a file is copied only if it both matches a pattern and is actually gitignored, so tracked files are never duplicated
+- **Hook-friendly**: files are copied before the post-creation worktree hook runs, so hook commands can rely on them
+
+For pattern syntax, the exact selection rule, and troubleshooting, see [docs/worktree-include.md](docs/worktree-include.md).
+
 ## Status Change Hooks
 
 CCManager can execute custom commands when Claude Code session status changes. This enables powerful automation workflows like desktop notifications, logging, or integration with other tools.

package/dist/components/App.js

@@ -7,6 +7,7 @@ import Dashboard from './Dashboard.js';
 import Session from './Session.js';
 import NewWorktree from './NewWorktree.js';
 import DeleteWorktree from './DeleteWorktree.js';
+import DeleteConfirmation from './DeleteConfirmation.js';
 import MergeWorktree from './MergeWorktree.js';
 import Configuration from './Configuration.js';
 import PresetSelector from './PresetSelector.js';
@@ -22,7 +23,7 @@ import { configReader } from '../services/config/configReader.js';
 import { ENV_VARS } from '../constants/env.js';
 import { MULTI_PROJECT_ERRORS } from '../constants/error.js';
 import { projectManager } from '../services/projectManager.js';
-import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
+import { generateWorktreeDirectory, isDeletableWorktree, } from '../utils/worktreeUtils.js';
 const App = ({ devcontainerConfig, multiProject, version, }) => {
     const { exit } = useApp();
     const [view, setView] = useState(multiProject ? 'project-list' : 'menu');
@@ -36,6 +37,8 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     const [selectedWorktree, setSelectedWorktree] = useState(null); // Store selected worktree for preset selection
     const [renameTarget, setRenameTarget] = useState(null);
     const [sessionActionsTarget, setSessionActionsTarget] = useState(null);
+    // Worktree awaiting confirmation of the per-row delete action
+    const [worktreeToDelete, setWorktreeToDelete] = useState(null);
     const [selectedProject, setSelectedProject] = useState(null); // Store selected project in multi-project mode
     const [configScope, setConfigScope] = useState('global'); // Store config scope for configuration view
     const [pendingMenuSessionLaunch, setPendingMenuSessionLaunch] = useState(null);
@@ -303,8 +306,9 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
                 return;
             case 'sessionActions':
                 setSessionActionsTarget({
+                    worktreePath: action.worktree.path,
                     session: action.session,
-                    worktreePath: action.worktreePath,
+                    worktree: action.worktree,
                 });
                 navigateWithClear('session-actions');
                 return;
@@ -520,7 +524,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         setPendingWorktreeCreation(null);
         setView('new-worktree');
     };
-    const handleDeleteWorktrees = async (worktreePaths, deleteBranch) => {
+    const handleDeleteWorktrees = async (worktreePaths, deleteBranch, options) => {
         // Set loading context before showing loading view
         setLoadingContext({ deleteBranch });
         setView('deleting-worktree');
@@ -558,7 +562,12 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         }
         else {
             // Show error
-            setView('delete-worktree');
+            if (options?.onError) {
+                options.onError();
+            }
+            else {
+                setView('delete-worktree');
+            }
         }
     };
     const handleCancelDeleteWorktree = () => {
@@ -670,10 +679,14 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             } }));
     }
     if (view === 'session-actions' && sessionActionsTarget) {
-        const { session: targetSession, worktreePath } = sessionActionsTarget;
-        const label = targetSession.sessionName
-            ? `${worktreePath} : ${targetSession.sessionName}`
-            : `${worktreePath} #${targetSession.sessionNumber}`;
+        const { session: targetSession, worktreePath, worktree: targetWorktree, } = sessionActionsTarget;
+        // A worktree row without a session has no session name to show; the
+        // worktree path is rendered on its own line by SessionActions.
+        const label = !targetSession
+            ? undefined
+            : targetSession.sessionName
+                ? targetSession.sessionName
+                : `Session #${targetSession.sessionNumber}`;
         const handleSessionAction = async (action) => {
             setSessionActionsTarget(null);
             switch (action) {
@@ -686,6 +699,8 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
                     }, { forceNew: true });
                     return;
                 case 'rename':
+                    if (!targetSession)
+                        return;
                     setRenameTarget({
                         id: targetSession.id,
                         name: targetSession.sessionName,
@@ -693,16 +708,38 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
                     navigateWithClear('rename-session');
                     return;
                 case 'kill':
+                    if (!targetSession)
+                        return;
                     sessionManager.destroySession(targetSession.id);
                     handleReturnToMenu();
                     return;
+                case 'deleteWorktree':
+                    if (!targetWorktree)
+                        return;
+                    setWorktreeToDelete(targetWorktree);
+                    navigateWithClear('confirm-delete-worktree');
+                    return;
             }
         };
-        return (_jsx(SessionActions, { sessionLabel: label, onSelect: handleSessionAction, onCancel: () => {
+        return (_jsx(SessionActions, { sessionLabel: label, worktreePath: worktreePath, hasSession: !!targetSession, canDeleteWorktree: !!targetWorktree && isDeletableWorktree(targetWorktree), onSelect: handleSessionAction, onCancel: () => {
                 setSessionActionsTarget(null);
                 handleReturnToMenu();
             } }));
     }
+    if (view === 'confirm-delete-worktree' && worktreeToDelete) {
+        const target = worktreeToDelete;
+        return (_jsx(DeleteConfirmation, { worktrees: [target], onConfirm: deleteBranch => {
+                setWorktreeToDelete(null);
+                void handleDeleteWorktrees([target.path], deleteBranch, {
+                    // The multi-select delete screen was never opened in this flow,
+                    // so surface the failure on the menu instead.
+                    onError: handleReturnToMenu,
+                });
+            }, onCancel: () => {
+                setWorktreeToDelete(null);
+                handleReturnToMenu();
+            } }));
+    }
     if (view === 'preset-selector') {
         return (_jsx(PresetSelector, { onSelect: handlePresetSelected, onCancel: handlePresetSelectorCancel }));
     }

package/dist/components/DeleteWorktree.js

@@ -1,6 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect } from 'react';
-import path from 'path';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import { Effect } from 'effect';
@@ -11,6 +10,7 @@ import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
 import { filterWorktreesByQuery } from '../utils/filterByQuery.js';
 import SearchableList from './SearchableList.js';
+import { isDeletableWorktree } from '../utils/worktreeUtils.js';
 const DeleteWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const [worktrees, setWorktrees] = useState([]);
     const [selectedIndices, setSelectedIndices] = useState(new Set());
@@ -34,18 +34,7 @@ const DeleteWorktree = ({ projectPath, onComplete, onCancel, }) => {
             try {
                 const allWorktrees = await Effect.runPromise(worktreeService.getWorktreesEffect());
                 if (!cancelled) {
-                    // Filter out main worktree and current working directory worktree
-                    const resolvedCwd = path.resolve(process.cwd());
-                    const deletableWorktrees = allWorktrees.filter(wt => {
-                        if (wt.isMainWorktree)
-                            return false;
-                        const resolvedPath = path.resolve(wt.path);
-                        if (resolvedCwd === resolvedPath ||
-                            resolvedCwd.startsWith(resolvedPath + path.sep)) {
-                            return false;
-                        }
-                        return true;
-                    });
+                    const deletableWorktrees = allWorktrees.filter(wt => isDeletableWorktree(wt));
                     setWorktrees(deletableWorktrees);
                     setIsLoading(false);
                 }

package/dist/components/Menu.js

@@ -41,11 +41,12 @@ const Menu = ({ sessionManager, worktreeService, initialSnapshot, onSnapshotChan
     const worktrees = useGitStatus(baseWorktrees, defaultBranch);
     // Seed from the in-memory session list so the cached snapshot renders with its
     // sessions attached. Waiting for the async git load would leave every row
-    // session-less for that window, disabling the Space session-actions shortcut.
+    // session-less for that window, hiding the session entries of the Space
+    // actions menu.
     const [sessions, setSessions] = useState(() => sessionManager.getAllSessions());
     const [items, setItems] = useState([]);
     const [recentProjects, setRecentProjects] = useState([]);
-    const [highlightedWorktreePath, setHighlightedWorktreePath] = useState(null);
+    const [highlightedWorktree, setHighlightedWorktree] = useState(null);
     const [highlightedSession, setHighlightedSession] = useState(undefined);
     const [autoApprovalToggleCounter, setAutoApprovalToggleCounter] = useState(0);
     const [stateFilter, setStateFilter] = useState('all');
@@ -288,16 +289,20 @@ const Menu = ({ sessionManager, worktreeService, initialSnapshot, onSnapshotChan
             }
         }
         setItems(menuItems);
-        // Ensure highlighted worktree path is valid for hotkey support
-        setHighlightedWorktreePath(prev => {
-            if (prev &&
-                menuItems.some(item => item.type === 'worktree' && item.worktree.path === prev)) {
-                return prev;
+        // Ensure highlighted worktree is valid for hotkey support
+        setHighlightedWorktree(prev => {
+            const stillListed = prev
+                ? menuItems.find(item => item.type === 'worktree' && item.worktree.path === prev.path)
+                : undefined;
+            if (stillListed && stillListed.type === 'worktree') {
+                // Re-read the item so the highlighted worktree keeps up with
+                // refreshed git status instead of pinning the stale object.
+                return stillListed.worktree;
             }
             const first = menuItems.find(item => item.type === 'worktree');
             if (first && first.type === 'worktree') {
                 setHighlightedSession(first.session);
-                return first.worktree.path;
+                return first.worktree;
             }
             setHighlightedSession(undefined);
             return null;
@@ -371,18 +376,19 @@ const Menu = ({ sessionManager, worktreeService, initialSnapshot, onSnapshotChan
         switch (keyPressed) {
             case 'a':
                 // Toggle auto-approval for the currently highlighted worktree
-                if (configReader.isAutoApprovalEnabled() && highlightedWorktreePath) {
-                    sessionManager.toggleAutoApprovalForWorktree(highlightedWorktreePath);
+                if (configReader.isAutoApprovalEnabled() && highlightedWorktree) {
+                    sessionManager.toggleAutoApprovalForWorktree(highlightedWorktree.path);
                     setAutoApprovalToggleCounter(c => c + 1);
                 }
                 break;
             case ' ':
-                // Open session actions for highlighted session
-                if (highlightedSession && highlightedWorktreePath) {
+                // Open the row actions for the highlighted worktree. Rows without a
+                // session open the same menu with only the worktree-level entries.
+                if (highlightedWorktree) {
                     onMenuAction({
                         type: 'sessionActions',
+                        worktree: highlightedWorktree,
                         session: highlightedSession,
-                        worktreePath: highlightedWorktreePath,
                     });
                 }
                 break;
@@ -477,13 +483,13 @@ const Menu = ({ sessionManager, worktreeService, initialSnapshot, onSnapshotChan
                         if (!item)
                             return;
                         if (item.type === 'worktree') {
-                            setHighlightedWorktreePath(item.worktree.path);
+                            setHighlightedWorktree(item.worktree);
                             setHighlightedSession(item.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
-                                ? `Controls: ↑↓ Navigate Enter Select | /-Search ESC-Clear 0-9 Quick Select Tab-State Filter 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 Tab-State Filter 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 | /-Search ESC-Clear 0-9 Quick Select Tab-State Filter Space-Worktree actions 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 Tab-State Filter Space-Worktree actions 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.test.js

@@ -319,8 +319,44 @@ describe('Menu component Effect-based error handling', () => {
         }
         expect(onMenuAction).toHaveBeenCalledWith({
             type: 'sessionActions',
+            worktree: cachedWorktree,
             session: cachedSession,
-            worktreePath: '/test/cached',
+        });
+    });
+    it('should open the actions menu with Space on a worktree row that has no session', async () => {
+        const { Effect } = await import('effect');
+        const sessionlessWorktree = {
+            path: '/test/no-session',
+            branch: 'feature/no-session',
+            isMainWorktree: false,
+            hasSession: false,
+        };
+        vi.spyOn(sessionManager, 'getAllSessions').mockReturnValue([]);
+        vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.succeed([sessionlessWorktree]));
+        vi.spyOn(worktreeService, 'getDefaultBranchEffect').mockReturnValue(Effect.succeed('main'));
+        const onMenuAction = vi.fn();
+        vi.mocked(useInput).mockClear();
+        render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, initialSnapshot: {
+                worktrees: [sessionlessWorktree],
+                defaultBranch: 'main',
+            }, onMenuAction: onMenuAction, version: "test" }));
+        await new Promise(resolve => setTimeout(resolve, 0));
+        // Menu's hotkey handler bails out when raw mode is unavailable.
+        const origSetRawMode = process.stdin.setRawMode;
+        process.stdin.setRawMode = vi.fn();
+        try {
+            const calls = vi.mocked(useInput).mock.calls;
+            const handler = calls[calls.length - 1]?.[0];
+            expect(handler).toBeDefined();
+            handler(' ', makeKey());
+        }
+        finally {
+            process.stdin.setRawMode = origSetRawMode;
+        }
+        expect(onMenuAction).toHaveBeenCalledWith({
+            type: 'sessionActions',
+            worktree: sessionlessWorktree,
+            session: undefined,
         });
     });
 });

package/dist/components/NewWorktree.js

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

package/dist/components/NewWorktree.test.js

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

package/dist/components/SessionActions.d.ts

@@ -1,7 +1,23 @@
 import React from 'react';
-export type SessionActionType = 'newSession' | 'rename' | 'kill';
+export type SessionActionType = 'newSession' | 'rename' | 'kill' | 'deleteWorktree';
 interface SessionActionsProps {
-    sessionLabel: string;
+    /**
+     * Name of the session this menu was opened from. Absent for a worktree row
+     * that has no session yet.
+     */
+    sessionLabel?: string;
+    worktreePath: string;
+    /**
+     * Whether the row this menu was opened from has a running session. Session
+     * specific actions (rename, close) are hidden when it does not.
+     */
+    hasSession?: boolean;
+    /**
+     * Whether the worktree of this row may be deleted; see isDeletableWorktree.
+     * The delete entry is hidden rather than shown-and-rejected so no
+     * unselectable option appears.
+     */
+    canDeleteWorktree?: boolean;
     onSelect: (action: SessionActionType) => void;
     onCancel: () => void;
 }

package/dist/components/SessionActions.js

@@ -1,29 +1,31 @@
 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, }) => {
+const buildItems = (hasSession, canDeleteWorktree) => {
+    const items = [
+        { label: 'S  New session in this worktree', value: 'newSession' },
+    ];
+    if (hasSession) {
+        items.push({ label: 'R  Rename this session', value: 'rename' });
+        items.push({ label: 'X  Close session', value: 'kill' });
+    }
+    if (canDeleteWorktree) {
+        items.push({ label: 'D  Delete this worktree', value: 'deleteWorktree' });
+    }
+    return items;
+};
+const SessionActions = ({ sessionLabel, worktreePath, hasSession = true, canDeleteWorktree = false, onSelect, onCancel, }) => {
+    const items = buildItems(hasSession, canDeleteWorktree);
     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;
+        const shortcut = items.find(item => item.label[0]?.toLowerCase() === input.toLowerCase());
+        if (shortcut) {
+            onSelect(shortcut.value);
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Session Actions" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: sessionLabel }) }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: items, onSelect: item => onSelect(item.value) }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "S/R/X or arrow keys + Enter | Escape to cancel" }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: hasSession ? 'Session Actions' : 'Worktree Actions' }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [sessionLabel && _jsx(Text, { dimColor: true, children: sessionLabel }), _jsxs(Text, { dimColor: true, children: ["Directory: ", worktreePath] })] }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: items, onSelect: item => onSelect(item.value) }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [items.map(item => item.label[0]).join('/'), " or arrow keys + Enter | Escape to cancel"] }) })] }));
 };
 export default SessionActions;

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

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