ccmanager 4.3.1 → 4.4.0

package/README.md

@@ -14,7 +14,9 @@ https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 - Switch between sessions seamlessly
 - Visual status indicators for session states (busy, waiting, idle)
 - Create, merge, and delete worktrees from within the app
+- **Restore sessions after a restart**: reopen the sessions that were running when CCManager last exited or crashed
 - **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
@@ -116,6 +118,22 @@ CCManager supports per-project configuration by placing a `.ccmanager.json` file
 
 For detailed configuration options and examples, see [docs/project-config.md](docs/project-config.md).
 
+### Configuring with an AI coding agent
+
+This repository doubles as a plugin marketplace providing the **`ccmanager-config`** skill, which teaches Claude Code or Codex the whole configuration schema and ships a validator for it:
+
+```bash
+# Claude Code
+claude plugin marketplace add kbwo/ccmanager
+claude plugin install ccmanager-config@ccmanager
+
+# Codex CLI
+codex plugin marketplace add kbwo/ccmanager
+codex plugin add ccmanager-config@ccmanager
+```
+
+Then just ask — "set this repo up to run codex in ccmanager", "notify me when a session is waiting for input", "why is my `.ccmanager.json` being ignored?". See [plugins/ccmanager-config/README.md](plugins/ccmanager-config/README.md).
+
 ## Supported AI Assistants
 
 CCManager supports multiple AI coding assistants with tailored state detection for each:
@@ -209,6 +227,42 @@ 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).
+
+## Restoring Sessions After a Restart
+
+Closing CCManager kills the AI assistant processes it started, so reopening it normally means finding each worktree again and starting each session by hand. To avoid that, CCManager keeps a record of the sessions it currently has open, and on the next start offers to launch them again:
+
+```
+Restore previous sessions
+
+Found 2 sessions from the last time ccmanager ran. Start them again?
+
+  feature-login — Main
+  fix-timeout (review) — Codex
+
+> Restore
+  Don't restore
+```
+
+- **What is restored**: each session's command preset is run again in its worktree, under the name you had given it. The previous terminal output and the conversation held inside the assistant are *not* restored — restoring means starting the same command again, not resuming where it left off. (To carry conversation context into a *new* worktree, see [Session Data Copying](#session-data-copying).)
+- **Survives a crash**: the record is written as sessions come and go, not on exit, so a crash, a `kill -9`, or a closed terminal leaves it intact.
+- **Only sessions that were still open**: a session you killed, or one whose command exited on its own, is dropped from the record and is not offered.
+- **Declining is remembered**: choosing "Don't restore" forgets those sessions, so the offer does not come back on the next start.
+- **Scope**: normally only the repository you are opening is considered. In [Multi-Project Mode](#multi-project-mode) the sessions of every recorded project are offered together at startup.
+- **Other running instances**: sessions belonging to another CCManager that is still open are left alone, so they are not started a second time.
+
+The record lives in `~/.config/ccmanager/sessions.json` (`%APPDATA%\ccmanager\sessions.json` on Windows).
+
 ## 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

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect, useCallback } from 'react';
 import { useApp, useInput, Box, Text } from 'ink';
 import { Effect } from 'effect';
@@ -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';
@@ -14,20 +15,32 @@ import RemoteBranchSelector from './RemoteBranchSelector.js';
 import LoadingSpinner from './LoadingSpinner.js';
 import SessionRename from './SessionRename.js';
 import SessionActions from './SessionActions.js';
+import RestoreSessions from './RestoreSessions.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { worktreeNameGenerator, generateFallbackBranchName, } from '../services/worktreeNameGenerator.js';
 import { logger } from '../utils/logger.js';
+import { formatErrorMessage } from '../utils/errorMessage.js';
+import { getCurrentRepositoryRoot } from '../utils/gitUtils.js';
+import { discardRestorableSessions, listRestorableSessions, restoreSessions, } from '../services/sessionRestorer.js';
 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');
     const [sessionManager, setSessionManager] = useState(() => globalSessionOrchestrator.getManagerForProject());
     const [worktreeService, setWorktreeService] = useState(() => new WorktreeService());
+    // Sessions that were open when ccmanager last ran and can be started again.
+    // Single-project mode only considers the repository being opened;
+    // multi-project mode considers every recorded project at once.
+    const [restorableSessions, setRestorableSessions] = useState(() => listRestorableSessions(multiProject ? {} : { projectPath: getCurrentRepositoryRoot() }));
+    const [view, setView] = useState(() => restorableSessions.length > 0
+        ? 'restore-sessions'
+        : multiProject
+            ? 'project-list'
+            : 'menu');
     const [activeSession, setActiveSession] = useState(null);
     const [error, setError] = useState(null);
     const [worktreeHookError, setWorktreeHookError] = useState(null);
@@ -36,6 +49,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);
@@ -84,21 +99,6 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         setWorktreeHookError(null);
         handleReturnToMenu();
     }, { isActive: view === 'worktree-hook-error' });
-    // Helper function to format error messages based on error type using _tag discrimination
-    const formatErrorMessage = (error) => {
-        switch (error._tag) {
-            case 'ProcessError':
-                return `Process error: ${error.message}`;
-            case 'ConfigError':
-                return `Configuration error (${error.reason}): ${error.details}`;
-            case 'GitError':
-                return `Git command failed: ${error.command} (exit ${error.exitCode})\n${error.stderr}`;
-            case 'FileSystemError':
-                return `File ${error.operation} failed for ${error.path}: ${error.cause}`;
-            case 'ValidationError':
-                return `Validation failed for ${error.field}: ${error.constraint}`;
-        }
-    };
     const formatPostCreationHookWarning = (error) => `Post-creation hook failed: ${error.message}`;
     const formatPreCreationHookError = (error) => error._tag === 'ProcessError'
         ? `Pre-creation hook failed: ${error.message}`
@@ -152,6 +152,31 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             setView('session');
         }, 10);
     }, []);
+    // The view the app starts on once the restore offer is out of the way.
+    const initialView = multiProject ? 'project-list' : 'menu';
+    const handleRestorePreviousSessions = useCallback(() => {
+        const records = restorableSessions;
+        setRestorableSessions([]);
+        setView('restoring-sessions');
+        void (async () => {
+            const outcome = await restoreSessions(records, {
+                multiProject: !!multiProject,
+            });
+            if (outcome.failures.length > 0) {
+                setError(`Could not restore ${outcome.failures.length} of ${records.length} sessions: ${outcome.failures
+                    .map(failure => `${failure.record.worktreePath} (${failure.message})`)
+                    .join(', ')}`);
+            }
+            navigateWithClear(initialView, () => {
+                setMenuKey(prev => prev + 1);
+            });
+        })();
+    }, [restorableSessions, multiProject, initialView, navigateWithClear]);
+    const handleDiscardPreviousSessions = useCallback(() => {
+        discardRestorableSessions(restorableSessions);
+        setRestorableSessions([]);
+        navigateWithClear(initialView);
+    }, [restorableSessions, initialView, navigateWithClear]);
     const startSessionForWorktree = useCallback(async (worktree, options) => {
         // If a specific session is provided, navigate to it directly
         if (options?.session) {
@@ -303,8 +328,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 +546,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 +584,12 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         }
         else {
             // Show error
-            setView('delete-worktree');
+            if (options?.onError) {
+                options.onError();
+            }
+            else {
+                setView('delete-worktree');
+            }
         }
     };
     const handleCancelDeleteWorktree = () => {
@@ -610,6 +641,12 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             setMenuKey(prev => prev + 1);
         });
     };
+    if (view === 'restore-sessions') {
+        return (_jsx(RestoreSessions, { sessions: restorableSessions, showProject: multiProject, onRestore: handleRestorePreviousSessions, onDiscard: handleDiscardPreviousSessions }));
+    }
+    if (view === 'restoring-sessions') {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(LoadingSpinner, { message: "Restoring previous sessions...", color: "cyan" }) }));
+    }
     if (view === 'project-list' && multiProject) {
         const projectsDir = process.env[ENV_VARS.MULTI_PROJECT_ROOT];
         if (!projectsDir) {
@@ -658,10 +695,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     }
     if (view === 'rename-session' && renameTarget) {
         return (_jsx(SessionRename, { currentName: renameTarget.name, onRename: name => {
-                const session = sessionManager.getSessionById(renameTarget.id);
-                if (session) {
-                    session.sessionName = name;
-                }
+                sessionManager.renameSession(renameTarget.id, name);
                 setRenameTarget(null);
                 handleReturnToMenu();
             }, onCancel: () => {
@@ -670,10 +704,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 +724,8 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
                     }, { forceNew: true });
                     return;
                 case 'rename':
+                    if (!targetSession)
+                        return;
                     setRenameTarget({
                         id: targetSession.id,
                         name: targetSession.sessionName,
@@ -693,16 +733,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/App.test.js

@@ -37,6 +37,20 @@ const configReaderMock = {
 const projectManagerMock = {
     addRecentProject: vi.fn(),
 };
+const listRestorableSessionsMock = vi.fn((_options) => []);
+const restoreSessionsMock = vi.fn(async (_records, _options) => ({
+    restored: 0,
+    failures: [],
+}));
+const discardRestorableSessionsMock = vi.fn((_records) => { });
+const createSessionRecord = (overrides = {}) => ({
+    id: 'record-1',
+    projectPath: '/repo',
+    worktreePath: '/repo/worktrees/feature',
+    ownerPid: 4242,
+    createdAt: 1,
+    ...overrides,
+});
 const worktreeNameGeneratorMock = {
     generateBranchNameEffect: vi.fn(() => Effect.succeed('fix/trim-worktree-name')),
 };
@@ -68,6 +82,15 @@ vi.mock('../services/globalSessionOrchestrator.js', () => ({
 vi.mock('../services/projectManager.js', () => ({
     projectManager: projectManagerMock,
 }));
+vi.mock('../services/sessionRestorer.js', () => ({
+    listRestorableSessions: (options) => listRestorableSessionsMock(options),
+    restoreSessions: (records, options) => restoreSessionsMock(records, options),
+    discardRestorableSessions: (records) => discardRestorableSessionsMock(records),
+    describeRecordPreset: () => 'Main',
+}));
+vi.mock('../utils/gitUtils.js', () => ({
+    getCurrentRepositoryRoot: () => '/repo',
+}));
 vi.mock('../services/config/configReader.js', () => ({
     configReader: configReaderMock,
 }));
@@ -143,6 +166,11 @@ beforeEach(() => {
     configReaderMock.getSelectPresetOnStart.mockReset();
     configReaderMock.getSelectPresetOnStart.mockReturnValue(false);
     projectManagerMock.addRecentProject.mockReset();
+    listRestorableSessionsMock.mockReset();
+    listRestorableSessionsMock.mockReturnValue([]);
+    restoreSessionsMock.mockReset();
+    restoreSessionsMock.mockResolvedValue({ restored: 0, failures: [] });
+    discardRestorableSessionsMock.mockReset();
     worktreeNameGeneratorMock.generateBranchNameEffect.mockReset();
     worktreeNameGeneratorMock.generateBranchNameEffect.mockImplementation(() => Effect.succeed('fix/trim-worktree-name'));
 });
@@ -156,6 +184,64 @@ describe('App component view state', () => {
         expect(lastFrame()).toContain('Menu View');
         unmount();
     });
+    it('offers to restore the sessions recorded by the previous run', async () => {
+        listRestorableSessionsMock.mockReturnValue([
+            createSessionRecord({ sessionName: 'review' }),
+        ]);
+        const { lastFrame, unmount } = render(_jsx(App, { version: "test" }));
+        await flush(40);
+        expect(listRestorableSessionsMock).toHaveBeenCalledWith({
+            projectPath: '/repo',
+        });
+        expect(lastFrame()).toContain('Restore previous sessions');
+        expect(lastFrame()).toContain('feature');
+        expect(lastFrame()).toContain('review');
+        unmount();
+    });
+    it('restores the recorded sessions and then shows the menu', async () => {
+        const record = createSessionRecord();
+        listRestorableSessionsMock.mockReturnValue([record]);
+        const { lastFrame, stdin, unmount } = render(_jsx(App, { version: "test" }));
+        await flush(40);
+        stdin.write('\r');
+        await waitForCondition(() => restoreSessionsMock.mock.calls.length > 0);
+        expect(restoreSessionsMock).toHaveBeenCalledWith([record], {
+            multiProject: false,
+        });
+        await waitForCondition(() => lastFrame()?.includes('Menu View') ?? false);
+        unmount();
+    });
+    it('forgets the recorded sessions when the restore offer is declined', async () => {
+        const record = createSessionRecord();
+        listRestorableSessionsMock.mockReturnValue([record]);
+        const { lastFrame, stdin, unmount } = render(_jsx(App, { version: "test" }));
+        await flush(40);
+        // Move from "Restore" to "Don't restore" before confirming.
+        stdin.write('\u001B[B');
+        await flush(10);
+        stdin.write('\r');
+        await waitForCondition(() => discardRestorableSessionsMock.mock.calls.length > 0);
+        expect(discardRestorableSessionsMock).toHaveBeenCalledWith([record]);
+        expect(restoreSessionsMock).not.toHaveBeenCalled();
+        await waitForCondition(() => lastFrame()?.includes('Menu View') ?? false);
+        unmount();
+    });
+    it('considers every recorded project in multi-project mode', async () => {
+        const original = process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        process.env[ENV_VARS.MULTI_PROJECT_ROOT] = '/tmp/projects';
+        listRestorableSessionsMock.mockReturnValue([createSessionRecord()]);
+        const { lastFrame, unmount } = render(_jsx(App, { multiProject: true, version: "test" }));
+        await flush(40);
+        expect(listRestorableSessionsMock).toHaveBeenCalledWith({});
+        expect(lastFrame()).toContain('Restore previous sessions');
+        unmount();
+        if (original === undefined) {
+            delete process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        }
+        else {
+            process.env[ENV_VARS.MULTI_PROJECT_ROOT] = original;
+        }
+    });
     it('renders the project list view first in multi-project mode', async () => {
         const original = process.env[ENV_VARS.MULTI_PROJECT_ROOT];
         process.env[ENV_VARS.MULTI_PROJECT_ROOT] = '/tmp/projects';

package/dist/components/Dashboard.js

@@ -11,6 +11,7 @@ import { WorktreeService } from '../services/worktreeService.js';
 import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, getStatusDisplay, } from '../constants/statusIcons.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
+import { useAvailableLabelWidth } from '../hooks/useAvailableLabelWidth.js';
 import { useGitStatus } from '../hooks/useGitStatus.js';
 import { truncateString, calculateColumnPositions, assembleSessionLabel, formatRelativeDate, displaySuffix, } from '../utils/worktreeUtils.js';
 import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from '../utils/gitStatus.js';
@@ -84,6 +85,9 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
         isSearchMode,
         hasError: !!displayError,
     });
+    // Room a row label may occupy; decides whether the session state tag gets
+    // its own aligned column or is appended to the branch name instead.
+    const availableLabelWidth = useAvailableLabelWidth();
     // Git status polling for session worktrees
     const enrichedWorktrees = useGitStatus(baseSessionWorktrees, baseSessionWorktrees.length > 0 ? 'main' : null);
     // Discover projects on mount
@@ -216,7 +220,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
                 const wt = enrichedWorktrees.find(w => w.path === entry.worktree.path) ||
                     entry.worktree;
                 const stateData = entry.session.stateMutex.getSnapshot();
-                const status = ` [${getStatusDisplay(stateData.state, stateData.backgroundTaskCount, stateData.teamMemberCount)}]`;
+                const status = `[${getStatusDisplay(stateData.state, stateData.backgroundTaskCount, stateData.teamMemberCount)}]`;
                 const fullBranchName = wt.branch
                     ? wt.branch.replace('refs/heads/', '')
                     : wt.path.split('/').pop() || 'detached';
@@ -225,7 +229,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
                 const worktreeSessionCount = sessionEntries.filter(e => e.worktree.path === entry.worktree.path &&
                     e.projectPath === entry.projectPath).length;
                 const sessionSuffix = displaySuffix(entry.session, worktreeSessionCount > 1);
-                const baseLabel = `${entry.projectName} :: ${branchName}${isMain}${sessionSuffix}${status}`;
+                const baseLabel = `${entry.projectName} :: ${branchName}${isMain}${sessionSuffix}`;
                 let fileChanges = '';
                 let aheadBehind = '';
                 let parentBranch = '';
@@ -245,6 +249,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
                     worktree: wt,
                     session: entry.session,
                     baseLabel,
+                    status,
                     searchableName: `${entry.projectName} :: ${fullBranchName}${isMain}`,
                     fileChanges,
                     aheadBehind,
@@ -255,6 +260,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
                     error: itemError,
                     lengths: {
                         base: stripAnsi(baseLabel).length,
+                        status: stripAnsi(status).length,
                         fileChanges: stripAnsi(fileChanges).length,
                         aheadBehind: stripAnsi(aheadBehind).length,
                         parentBranch: stripAnsi(parentBranch).length,
@@ -264,7 +270,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
                     },
                 };
             });
-            const columns = calculateColumnPositions(sessionWorkItems);
+            const columns = calculateColumnPositions(sessionWorkItems, availableLabelWidth);
             if (!isSearchMode) {
                 menuItems.push({
                     type: 'common',
@@ -369,6 +375,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
         projectDisplayNames,
         searchQuery,
         isSearchMode,
+        availableLabelWidth,
     ]);
     // Refresh handler
     const refreshAll = () => {

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

@@ -10,6 +10,7 @@ import { prepareSessionItems, calculateColumnPositions, assembleSessionLabel, }
 import { projectManager } from '../services/projectManager.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
+import { useAvailableLabelWidth } from '../hooks/useAvailableLabelWidth.js';
 import { filterSessionItemsByQuery, filterSessionItemsByState, cycleSessionStateFilter, getSessionStateFilterLabel, } from '../utils/filterByQuery.js';
 import SearchableList from './SearchableList.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
@@ -41,11 +42,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');
@@ -59,6 +61,9 @@ const Menu = ({ sessionManager, worktreeService, initialSnapshot, onSnapshotChan
     });
     // Get worktree configuration for sorting
     const worktreeConfig = configReader.getWorktreeConfig();
+    // Room a row label may occupy; decides whether the session state tag gets
+    // its own aligned column or is appended to the branch name instead.
+    const availableLabelWidth = useAvailableLabelWidth();
     useEffect(() => {
         let cancelled = false;
         // These operations are independent. Run them concurrently so the initial
@@ -153,7 +158,7 @@ const Menu = ({ sessionManager, worktreeService, initialSnapshot, onSnapshotChan
         const items = prepareSessionItems(worktrees, sessions, {
             sortByLastSession: worktreeConfig.sortByLastSession,
         });
-        const columnPositions = calculateColumnPositions(items);
+        const columnPositions = calculateColumnPositions(items, availableLabelWidth);
         // Filter session items based on search query, matching the name shown in
         // the menu (branch name, " (main)", and session name) plus the path, then
         // narrow to the selected session state. The two filters are independent
@@ -288,16 +293,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;
@@ -315,6 +324,7 @@ const Menu = ({ sessionManager, worktreeService, initialSnapshot, onSnapshotChan
         autoApprovalToggleCounter,
         sessionManager,
         worktreeConfig.sortByLastSession,
+        availableLabelWidth,
     ]);
     // Handle hotkeys
     useInput((input, key) => {
@@ -371,18 +381,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 +488,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;