ccmanager 4.3.1 → 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
-            ? targetSession.sessionName
-            : `Session #${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, worktreePath: worktreePath, 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/SessionActions.d.ts

@@ -1,8 +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, worktreePath, 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" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: sessionLabel }), _jsxs(Text, { dimColor: true, children: ["Directory: ", worktreePath] })] }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: items, onSelect: item => onSelect(item.value) }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "S/R/X or arrow keys + Enter | Escape to cancel" }) })] }));
+    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 {};

package/dist/components/SessionActions.test.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { useInput } from 'ink';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import SessionActions from './SessionActions.js';
+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 ink to avoid stdin issues and to capture the hotkey handler
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useInput: vi.fn(),
+    };
+});
+// Mock SelectInput to render items as simple text
+vi.mock('ink-select-input', async () => {
+    const React = await vi.importActual('react');
+    const { Text, Box } = await vi.importActual('ink');
+    return {
+        default: ({ items }) => React.createElement(Box, { flexDirection: 'column' }, items.map((item, index) => React.createElement(Text, { key: index }, item.label))),
+    };
+});
+const getLastInputHandler = () => {
+    const calls = vi.mocked(useInput).mock.calls;
+    const handler = calls[calls.length - 1]?.[0];
+    expect(handler).toBeDefined();
+    return handler;
+};
+describe('SessionActions', () => {
+    beforeEach(() => {
+        vi.mocked(useInput).mockClear();
+    });
+    it('should show session actions and the delete entry for a deletable worktree', () => {
+        const { lastFrame } = render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo/worktrees/feature", hasSession: true, canDeleteWorktree: true, onSelect: vi.fn(), onCancel: vi.fn() }));
+        const frame = lastFrame();
+        expect(frame).toContain('Session Actions');
+        expect(frame).toContain('New session in this worktree');
+        expect(frame).toContain('Rename this session');
+        expect(frame).toContain('Close session');
+        expect(frame).toContain('Delete this worktree');
+    });
+    it('should hide session-specific actions for a worktree without a session', () => {
+        const { lastFrame } = render(_jsx(SessionActions, { worktreePath: "/repo/worktrees/feature", hasSession: false, canDeleteWorktree: true, onSelect: vi.fn(), onCancel: vi.fn() }));
+        const frame = lastFrame();
+        expect(frame).toContain('Worktree Actions');
+        expect(frame).toContain('New session in this worktree');
+        expect(frame).toContain('Delete this worktree');
+        expect(frame).not.toContain('Rename this session');
+        expect(frame).not.toContain('Close session');
+    });
+    it('should hide the delete entry when the worktree cannot be deleted', () => {
+        const { lastFrame } = render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo", hasSession: true, canDeleteWorktree: false, onSelect: vi.fn(), onCancel: vi.fn() }));
+        expect(lastFrame()).not.toContain('Delete this worktree');
+    });
+    it('should dispatch deleteWorktree on the D hotkey when deletion is offered', () => {
+        const onSelect = vi.fn();
+        render(_jsx(SessionActions, { worktreePath: "/repo/worktrees/feature", hasSession: false, canDeleteWorktree: true, onSelect: onSelect, onCancel: vi.fn() }));
+        getLastInputHandler()('d', makeKey());
+        expect(onSelect).toHaveBeenCalledWith('deleteWorktree');
+    });
+    it('should ignore hotkeys of actions that are not offered', () => {
+        const onSelect = vi.fn();
+        render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo", hasSession: true, canDeleteWorktree: false, onSelect: onSelect, onCancel: vi.fn() }));
+        const handler = getLastInputHandler();
+        handler('d', makeKey());
+        expect(onSelect).not.toHaveBeenCalled();
+        handler('x', makeKey());
+        expect(onSelect).toHaveBeenCalledWith('kill');
+    });
+    it('should cancel on Escape', () => {
+        const onCancel = vi.fn();
+        render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo", hasSession: true, canDeleteWorktree: true, onSelect: vi.fn(), onCancel: onCancel }));
+        getLastInputHandler()('', makeKey({ escape: true }));
+        expect(onCancel).toHaveBeenCalled();
+    });
+});

package/dist/services/worktreeService.d.ts

@@ -155,6 +155,18 @@ export declare class WorktreeService {
      * @throws {FileSystemError} When copying the directory fails
      */
     private copyClaudeDirectoryFromBaseBranchEffect;
+    /**
+     * Effect-based copyWorktreeIncludeFiles operation.
+     * Copies the gitignored files a `.worktreeinclude` file at the repository
+     * root selects (see src/utils/worktreeInclude.ts) into the new worktree.
+     * A no-op when no `.worktreeinclude` file exists, so this always runs
+     * unconditionally rather than being gated by a config flag.
+     *
+     * @param {string} gitRoot - Absolute path to the main checkout
+     * @param {string} targetWorktreePath - Path of the newly created worktree
+     * @returns {Effect.Effect<void, FileSystemError, never>} Effect that completes successfully or fails with FileSystemError
+     */
+    private copyWorktreeIncludeFilesEffect;
     /**
      * Effect-based getDefaultBranch operation
      * Returns Effect that may fail with GitError

package/dist/services/worktreeService.js

@@ -7,6 +7,7 @@ import { GitError, FileSystemError } from '../types/errors.js';
 import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
 import { getClaudeProjectsDir, pathToClaudeProjectName, } from '../utils/claudeDir.js';
 import { executeWorktreePostCreationHook, executeWorktreePreCreationHook, } from '../utils/hookExecutor.js';
+import { copyWorktreeIncludeFiles } from '../utils/worktreeInclude.js';
 import { configReader } from './config/configReader.js';
 import { logger } from '../utils/logger.js';
 const CLAUDE_DIR = '.claude';
@@ -448,6 +449,27 @@ export class WorktreeService {
             });
         });
     }
+    /**
+     * Effect-based copyWorktreeIncludeFiles operation.
+     * Copies the gitignored files a `.worktreeinclude` file at the repository
+     * root selects (see src/utils/worktreeInclude.ts) into the new worktree.
+     * A no-op when no `.worktreeinclude` file exists, so this always runs
+     * unconditionally rather than being gated by a config flag.
+     *
+     * @param {string} gitRoot - Absolute path to the main checkout
+     * @param {string} targetWorktreePath - Path of the newly created worktree
+     * @returns {Effect.Effect<void, FileSystemError, never>} Effect that completes successfully or fails with FileSystemError
+     */
+    copyWorktreeIncludeFilesEffect(gitRoot, targetWorktreePath) {
+        return Effect.try({
+            try: () => copyWorktreeIncludeFiles(gitRoot, targetWorktreePath),
+            catch: (error) => new FileSystemError({
+                operation: 'write',
+                path: targetWorktreePath,
+                cause: String(error),
+            }),
+        });
+    }
     /**
      * Effect-based getDefaultBranch operation
      * Returns Effect that may fail with GitError
@@ -967,6 +989,14 @@ export class WorktreeService {
                     return Effect.succeed(undefined);
                 });
             }
+            // Copy files selected by a .worktreeinclude file, if one exists at
+            // the repository root. Runs unconditionally (no config flag) and
+            // before the post-creation hook, so hook commands can rely on the
+            // copied files (e.g. .env) already being in place.
+            yield* Effect.catchAll(self.copyWorktreeIncludeFilesEffect(absoluteGitRoot, resolvedPath), (error) => {
+                console.error('Warning: Failed to copy .worktreeinclude files:', error);
+                return Effect.succeed(undefined);
+            });
             // Execute post-creation hook if configured
             const worktreeHooks = configReader.getWorktreeHooks();
             logger.info('Worktree hook config after creation', {

package/dist/services/worktreeService.test.js

@@ -1,7 +1,8 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { WorktreeService } from './worktreeService.js';
 import { execSync } from 'child_process';
-import { existsSync, statSync } from 'fs';
+import { existsSync, statSync, cpSync, mkdirSync } from 'fs';
+import path from 'path';
 import { configReader } from './config/configReader.js';
 import { Effect } from 'effect';
 import { GitError, ProcessError } from '../types/errors.js';
@@ -33,11 +34,20 @@ vi.mock('../utils/hookExecutor.js', () => ({
 const mockedExecSync = vi.mocked(execSync);
 const mockedExistsSync = vi.mocked(existsSync);
 const mockedStatSync = vi.mocked(statSync);
+const mockedCpSync = vi.mocked(cpSync);
+const mockedMkdirSync = vi.mocked(mkdirSync);
 const mockedGetWorktreeHooks = vi.mocked(configReader.getWorktreeHooks);
 describe('WorktreeService', () => {
     let service;
     beforeEach(() => {
         vi.clearAllMocks();
+        // vi.clearAllMocks() clears call history but not custom implementations,
+        // so a test-specific existsSync/statSync mock (e.g. in
+        // hasClaudeDirectoryInBranchEffect below) would otherwise leak into
+        // every later test in this file. Reset them to the automock default
+        // (returns undefined) so each test starts from a clean slate.
+        mockedExistsSync.mockReset();
+        mockedStatSync.mockReset();
         // Mock git rev-parse --git-common-dir to return a predictable path
         mockedExecSync.mockImplementation((cmd, _options) => {
             if (typeof cmd === 'string' && cmd === 'git rev-parse --git-common-dir') {
@@ -837,6 +847,50 @@ branch refs/heads/feature
                 isMainWorktree: false,
             });
         });
+        it('should copy .worktreeinclude files from the main checkout into the new worktree', async () => {
+            mockedExistsSync.mockImplementation(filePath => {
+                const target = String(filePath);
+                if (target.endsWith('.worktreeinclude'))
+                    return true;
+                // The source .env lives in the main checkout (gitRoot); the same
+                // relative path under the new worktree must not exist yet.
+                if (target === path.join('/fake/path', '.env'))
+                    return true;
+                return false;
+            });
+            mockedStatSync.mockImplementation(() => ({ isFile: () => true }));
+            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\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/')) {
+                        throw new Error('Remote branch not found');
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                    if (cmd.includes('git ls-files --others --ignored')) {
+                        return '.env\0';
+                    }
+                    if (cmd === 'git check-ignore --stdin -z') {
+                        return '.env\0';
+                    }
+                }
+                return '';
+            });
+            const effect = service.createWorktreeEffect('/path/to/worktree', 'new-feature', 'main');
+            const result = await Effect.runPromise(effect);
+            expect(result.worktree.path).toBe('/path/to/worktree');
+            expect(mockedMkdirSync).toHaveBeenCalledWith(path.dirname(path.join('/path/to/worktree', '.env')), { recursive: true });
+            expect(mockedCpSync).toHaveBeenCalledWith(path.join('/fake/path', '.env'), path.join('/path/to/worktree', '.env'), { recursive: true, preserveTimestamps: true });
+        });
         it('should create local branch from remote ref when only remote branch exists', async () => {
             const executedCommands = [];
             mockedExecSync.mockImplementation((cmd, _options) => {

package/dist/types/index.d.ts

@@ -75,8 +75,8 @@ export type MenuAction = {
     sessionId: string;
 } | {
     type: 'sessionActions';
-    session: Session;
-    worktreePath: string;
+    worktree: Worktree;
+    session?: Session;
 } | {
     type: 'deleteWorktree';
 } | {

package/dist/utils/worktreeInclude.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Filename for the convention shared across worktree-aware tools (Claude Code,
+ * Conductor, OpenAI Codex, git-worktreeinclude, worktrunk): a gitignore-syntax
+ * file at the repository root that lists gitignored files to carry into every
+ * new worktree.
+ */
+export declare const WORKTREE_INCLUDE_FILENAME = ".worktreeinclude";
+/**
+ * Resolves which files a `.worktreeinclude` file selects, relative to `gitRoot`.
+ *
+ * A file is selected only when both hold:
+ * - it matches a pattern in `.worktreeinclude` (gitignore syntax: comments,
+ *   negation with `!`, anchoring with `/`, `**` globs)
+ * - Git already ignores it (nested `.gitignore` files, `.git/info/exclude`,
+ *   and `core.excludesfile` all apply)
+ *
+ * This mirrors the safety rule every tool that supports `.worktreeinclude`
+ * documents: listing a pattern never makes a tracked file eligible, and it
+ * never makes an otherwise-untracked-but-not-ignored file eligible either.
+ *
+ * @param gitRoot - Absolute path to the main checkout (repository root)
+ * @returns Repository-relative paths (forward-slash separated, as Git reports them)
+ */
+export declare function resolveWorktreeIncludeFiles(gitRoot: string): string[];
+/**
+ * Copies the files a `.worktreeinclude` file selects from the main checkout
+ * into a freshly created worktree. No-ops when no `.worktreeinclude` file
+ * exists. Never overwrites a file that already exists at the destination.
+ *
+ * @param gitRoot - Absolute path to the main checkout (repository root)
+ * @param targetWorktreePath - Absolute path to the newly created worktree
+ */
+export declare function copyWorktreeIncludeFiles(gitRoot: string, targetWorktreePath: string): void;

package/dist/utils/worktreeInclude.js

@@ -0,0 +1,100 @@
+import { execSync } from 'child_process';
+import { existsSync, statSync, mkdirSync, cpSync } from 'fs';
+import path from 'path';
+import { logger } from './logger.js';
+/**
+ * Filename for the convention shared across worktree-aware tools (Claude Code,
+ * Conductor, OpenAI Codex, git-worktreeinclude, worktrunk): a gitignore-syntax
+ * file at the repository root that lists gitignored files to carry into every
+ * new worktree.
+ */
+export const WORKTREE_INCLUDE_FILENAME = '.worktreeinclude';
+/**
+ * Resolves which files a `.worktreeinclude` file selects, relative to `gitRoot`.
+ *
+ * A file is selected only when both hold:
+ * - it matches a pattern in `.worktreeinclude` (gitignore syntax: comments,
+ *   negation with `!`, anchoring with `/`, `**` globs)
+ * - Git already ignores it (nested `.gitignore` files, `.git/info/exclude`,
+ *   and `core.excludesfile` all apply)
+ *
+ * This mirrors the safety rule every tool that supports `.worktreeinclude`
+ * documents: listing a pattern never makes a tracked file eligible, and it
+ * never makes an otherwise-untracked-but-not-ignored file eligible either.
+ *
+ * @param gitRoot - Absolute path to the main checkout (repository root)
+ * @returns Repository-relative paths (forward-slash separated, as Git reports them)
+ */
+export function resolveWorktreeIncludeFiles(gitRoot) {
+    const includeFilePath = path.join(gitRoot, WORKTREE_INCLUDE_FILENAME);
+    if (!existsSync(includeFilePath) || !statSync(includeFilePath).isFile()) {
+        return [];
+    }
+    let candidatesOutput;
+    try {
+        // --exclude-from applies ONLY .worktreeinclude's own patterns (no
+        // --exclude-standard), so this lists untracked files matching those
+        // patterns regardless of whether the repository's real .gitignore
+        // covers them.
+        candidatesOutput = execSync(`git ls-files --others --ignored --exclude-from="${WORKTREE_INCLUDE_FILENAME}" -z`, { cwd: gitRoot, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+    }
+    catch (error) {
+        logger.error('Failed to resolve .worktreeinclude candidates', {
+            gitRoot,
+            error: String(error),
+        });
+        return [];
+    }
+    const candidates = candidatesOutput
+        .split('\0')
+        .filter(entry => entry.length > 0);
+    if (candidates.length === 0) {
+        return [];
+    }
+    // Confirm each candidate against the repository's real ignore rules.
+    // git check-ignore --stdin echoes back only the paths it is asked about
+    // that ARE ignored, so this is the second half of the intersection.
+    let ignoredOutput;
+    try {
+        ignoredOutput = execSync('git check-ignore --stdin -z', {
+            cwd: gitRoot,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            input: candidates.join('\0') + '\0',
+        });
+    }
+    catch (error) {
+        // Exit code 1 (no matches) surfaces as a thrown error; anything already
+        // written to stdout before that is still the correct partial result.
+        const execError = error;
+        ignoredOutput = execError.stdout ?? '';
+    }
+    return ignoredOutput.split('\0').filter(entry => entry.length > 0);
+}
+/**
+ * Copies the files a `.worktreeinclude` file selects from the main checkout
+ * into a freshly created worktree. No-ops when no `.worktreeinclude` file
+ * exists. Never overwrites a file that already exists at the destination.
+ *
+ * @param gitRoot - Absolute path to the main checkout (repository root)
+ * @param targetWorktreePath - Absolute path to the newly created worktree
+ */
+export function copyWorktreeIncludeFiles(gitRoot, targetWorktreePath) {
+    const relativePaths = resolveWorktreeIncludeFiles(gitRoot);
+    for (const relativePath of relativePaths) {
+        const sourcePath = path.join(gitRoot, relativePath);
+        const targetPath = path.join(targetWorktreePath, relativePath);
+        if (!existsSync(sourcePath)) {
+            continue;
+        }
+        if (existsSync(targetPath)) {
+            logger.warn('Skipping .worktreeinclude copy, destination already exists', {
+                relativePath,
+                targetPath,
+            });
+            continue;
+        }
+        mkdirSync(path.dirname(targetPath), { recursive: true });
+        cpSync(sourcePath, targetPath, { recursive: true, preserveTimestamps: true });
+    }
+}

package/dist/utils/worktreeInclude.test.d.ts

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

package/dist/utils/worktreeInclude.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { resolveWorktreeIncludeFiles, copyWorktreeIncludeFiles, } from './worktreeInclude.js';
+describe('worktreeInclude', () => {
+    const testDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ccmanager-worktreeinclude-test-')));
+    let repoCount = 0;
+    let gitRoot;
+    beforeEach(() => {
+        repoCount += 1;
+        gitRoot = path.join(testDir, `repo-${repoCount}`);
+        fs.mkdirSync(gitRoot, { recursive: true });
+        execSync('git init', { cwd: gitRoot });
+        execSync('git config user.email "test@test.com"', { cwd: gitRoot });
+        execSync('git config user.name "Test User"', { cwd: gitRoot });
+        fs.writeFileSync(path.join(gitRoot, 'README.md'), '# repo');
+        execSync('git add README.md', { cwd: gitRoot });
+        execSync('git commit -m "initial commit"', { cwd: gitRoot });
+    });
+    afterAll(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    it('returns an empty list when no .worktreeinclude file exists', () => {
+        fs.writeFileSync(path.join(gitRoot, '.env'), 'SECRET=1');
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual([]);
+    });
+    it('selects a file that matches .worktreeinclude and is gitignored', () => {
+        fs.writeFileSync(path.join(gitRoot, '.gitignore'), '.env\n');
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), '.env\n');
+        fs.writeFileSync(path.join(gitRoot, '.env'), 'SECRET=1');
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual(['.env']);
+    });
+    it('excludes a file that matches .worktreeinclude but is not gitignored', () => {
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), 'notes.txt\n');
+        fs.writeFileSync(path.join(gitRoot, 'notes.txt'), 'not ignored');
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual([]);
+    });
+    it('excludes a tracked file even when it matches .worktreeinclude', () => {
+        fs.writeFileSync(path.join(gitRoot, '.gitignore'), 'tracked.env\n');
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), 'tracked.env\n');
+        fs.writeFileSync(path.join(gitRoot, 'tracked.env'), 'SECRET=1');
+        execSync('git add -f tracked.env', { cwd: gitRoot });
+        execSync('git commit -m "track tracked.env"', { cwd: gitRoot });
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual([]);
+    });
+    it('resolves every file under a directory glob pattern', () => {
+        fs.writeFileSync(path.join(gitRoot, '.gitignore'), 'certs/\n');
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), 'certs/local/**\n');
+        fs.mkdirSync(path.join(gitRoot, 'certs', 'local', 'nested'), {
+            recursive: true,
+        });
+        fs.writeFileSync(path.join(gitRoot, 'certs', 'local', 'cert.pem'), 'cert');
+        fs.writeFileSync(path.join(gitRoot, 'certs', 'local', 'nested', 'key.pem'), 'key');
+        expect(resolveWorktreeIncludeFiles(gitRoot).sort()).toEqual([
+            'certs/local/cert.pem',
+            'certs/local/nested/key.pem',
+        ]);
+    });
+    describe('copyWorktreeIncludeFiles', () => {
+        it('copies selected files into the target worktree, recreating nested directories', () => {
+            fs.writeFileSync(path.join(gitRoot, '.gitignore'), '.env\ncerts/\n');
+            fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), '.env\ncerts/local/**\n');
+            fs.writeFileSync(path.join(gitRoot, '.env'), 'SECRET=1');
+            fs.mkdirSync(path.join(gitRoot, 'certs', 'local'), { recursive: true });
+            fs.writeFileSync(path.join(gitRoot, 'certs', 'local', 'cert.pem'), 'cert');
+            const targetWorktreePath = path.join(testDir, `target-${repoCount}`);
+            fs.mkdirSync(targetWorktreePath, { recursive: true });
+            copyWorktreeIncludeFiles(gitRoot, targetWorktreePath);
+            expect(fs.readFileSync(path.join(targetWorktreePath, '.env'), 'utf8')).toBe('SECRET=1');
+            expect(fs.readFileSync(path.join(targetWorktreePath, 'certs', 'local', 'cert.pem'), 'utf8')).toBe('cert');
+        });
+        it('does not overwrite a file that already exists at the destination', () => {
+            fs.writeFileSync(path.join(gitRoot, '.gitignore'), '.env\n');
+            fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), '.env\n');
+            fs.writeFileSync(path.join(gitRoot, '.env'), 'SOURCE');
+            const targetWorktreePath = path.join(testDir, `target-${repoCount}`);
+            fs.mkdirSync(targetWorktreePath, { recursive: true });
+            fs.writeFileSync(path.join(targetWorktreePath, '.env'), 'EXISTING');
+            copyWorktreeIncludeFiles(gitRoot, targetWorktreePath);
+            expect(fs.readFileSync(path.join(targetWorktreePath, '.env'), 'utf8')).toBe('EXISTING');
+        });
+        it('is a no-op when no .worktreeinclude file exists', () => {
+            const targetWorktreePath = path.join(testDir, `target-${repoCount}`);
+            fs.mkdirSync(targetWorktreePath, { recursive: true });
+            expect(() => copyWorktreeIncludeFiles(gitRoot, targetWorktreePath)).not.toThrow();
+            expect(fs.readdirSync(targetWorktreePath)).toEqual([]);
+        });
+    });
+});

package/dist/utils/worktreeUtils.d.ts

@@ -78,3 +78,16 @@ export declare function calculateColumnPositions(items: SessionItem[]): {
  * Assembles the final worktree label with proper column alignment
  */
 export declare function assembleSessionLabel(item: SessionItem, columns: ReturnType<typeof calculateColumnPositions>): string;
+/**
+ * Whether a worktree may be deleted by CCManager.
+ *
+ * Two worktrees are off limits:
+ * - the main worktree, because git refuses to remove it and the repository
+ *   would be left without a checkout;
+ * - the worktree that contains the current working directory, because removing
+ *   the directory CCManager is running in breaks the running process.
+ *
+ * Single source of truth for the rule, shared by the multi-select delete screen
+ * and the per-row delete action.
+ */
+export declare function isDeletableWorktree(worktree: Pick<Worktree, 'path' | 'isMainWorktree'>, cwd?: string): boolean;

package/dist/utils/worktreeUtils.js

@@ -340,3 +340,26 @@ export function assembleSessionLabel(item, columns) {
     }
     return label;
 }
+/**
+ * Whether a worktree may be deleted by CCManager.
+ *
+ * Two worktrees are off limits:
+ * - the main worktree, because git refuses to remove it and the repository
+ *   would be left without a checkout;
+ * - the worktree that contains the current working directory, because removing
+ *   the directory CCManager is running in breaks the running process.
+ *
+ * Single source of truth for the rule, shared by the multi-select delete screen
+ * and the per-row delete action.
+ */
+export function isDeletableWorktree(worktree, cwd = process.cwd()) {
+    if (worktree.isMainWorktree)
+        return false;
+    const resolvedCwd = path.resolve(cwd);
+    const resolvedPath = path.resolve(worktree.path);
+    if (resolvedCwd === resolvedPath ||
+        resolvedCwd.startsWith(resolvedPath + path.sep)) {
+        return false;
+    }
+    return true;
+}

package/dist/utils/worktreeUtils.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { generateWorktreeDirectory, extractBranchParts, truncateString, prepareSessionItems, calculateColumnPositions, assembleSessionLabel, } from './worktreeUtils.js';
+import { generateWorktreeDirectory, extractBranchParts, truncateString, prepareSessionItems, calculateColumnPositions, assembleSessionLabel, isDeletableWorktree, } from './worktreeUtils.js';
 import { execSync } from 'child_process';
 import { Mutex, createInitialSessionStateData } from './mutex.js';
 import { createStateDetector } from '../services/stateDetector/index.js';
@@ -325,3 +325,22 @@ describe('column alignment', () => {
         expect(plain.indexOf('+10 -5')).toBe(21); // Should start at column 21
     });
 });
+describe('isDeletableWorktree', () => {
+    it('should reject the main worktree', () => {
+        expect(isDeletableWorktree({ path: '/repo', isMainWorktree: true }, '/somewhere/else')).toBe(false);
+    });
+    it('should reject the worktree holding the current working directory', () => {
+        expect(isDeletableWorktree({ path: '/repo/worktrees/feature', isMainWorktree: false }, '/repo/worktrees/feature')).toBe(false);
+    });
+    it('should reject a worktree that is an ancestor of the current working directory', () => {
+        expect(isDeletableWorktree({ path: '/repo/worktrees/feature', isMainWorktree: false }, '/repo/worktrees/feature/src/components')).toBe(false);
+    });
+    it('should accept a sibling worktree with a shared path prefix', () => {
+        // '/repo/worktrees/feature-2' starts with the '/repo/worktrees/feature'
+        // string but is a different directory, so it stays deletable.
+        expect(isDeletableWorktree({ path: '/repo/worktrees/feature', isMainWorktree: false }, '/repo/worktrees/feature-2')).toBe(true);
+    });
+    it('should accept an unrelated linked worktree', () => {
+        expect(isDeletableWorktree({ path: '/repo/worktrees/feature', isMainWorktree: false }, '/repo')).toBe(true);
+    });
+});

package/package.json

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