ccmanager 4.1.21 → 4.1.23

package/dist/components/Menu.js

@@ -10,7 +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 { filterSessionItemsByQuery } from '../utils/filterByQuery.js';
+import { filterSessionItemsByQuery, filterSessionItemsByState, cycleSessionStateFilter, getSessionStateFilterLabel, } from '../utils/filterByQuery.js';
 import SearchableList from './SearchableList.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { configReader } from '../services/config/configReader.js';
@@ -40,6 +40,7 @@ const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentPro
     const [highlightedWorktreePath, setHighlightedWorktreePath] = useState(null);
     const [highlightedSession, setHighlightedSession] = useState(undefined);
     const [autoApprovalToggleCounter, setAutoApprovalToggleCounter] = useState(0);
+    const [stateFilter, setStateFilter] = useState('all');
     // Use the search mode hook
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
         isDisabled: !!error || !!loadError,
@@ -125,8 +126,10 @@ const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentPro
         });
         const columnPositions = calculateColumnPositions(items);
         // Filter session items based on search query, matching the name shown in
-        // the menu (branch name, " (main)", and session name) plus the path.
-        const filteredItems = filterSessionItemsByQuery(items, searchQuery);
+        // the menu (branch name, " (main)", and session name) plus the path, then
+        // narrow to the selected session state. The two filters are independent
+        // dimensions and compose: both can be active at once.
+        const filteredItems = filterSessionItemsByState(filterSessionItemsByQuery(items, searchQuery), stateFilter);
         // Build menu items with proper alignment
         const menuItems = filteredItems.map((item, index) => {
             const baseLabel = assembleSessionLabel(item, columnPositions);
@@ -279,12 +282,13 @@ const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentPro
         recentProjects,
         searchQuery,
         isSearchMode,
+        stateFilter,
         autoApprovalToggleCounter,
         sessionManager,
         worktreeConfig.sortByLastSession,
     ]);
     // Handle hotkeys
-    useInput((input, _key) => {
+    useInput((input, key) => {
         // Skip in test environment to avoid stdin.ref error
         if (!process.stdin.setRawMode) {
             return;
@@ -303,6 +307,11 @@ const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentPro
         if (isSearchMode) {
             return;
         }
+        // Cycle the session-state filter: Tab forward, Shift+Tab backward.
+        if (key.tab) {
+            setStateFilter(prev => cycleSessionStateFilter(prev, key.shift ? 'prev' : 'next'));
+            return;
+        }
         const keyPressed = input.toLowerCase();
         // Handle number keys 0-9 for worktree selection
         if (/^[0-9]$/.test(keyPressed)) {
@@ -429,7 +438,7 @@ const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentPro
             });
         }
     };
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, color: "green", children: ["CCManager - Claude Code Worktree Manager v", version] }), projectName && (_jsx(Text, { bold: true, color: "green", children: projectName }))] }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Select a worktree to start or resume a Claude Code session:" }) }), _jsx(SearchableList, { isSearchMode: isSearchMode, searchQuery: searchQuery, onSearchQueryChange: setSearchQuery, selectedIndex: selectedIndex, items: items, limit: limit, placeholder: "Type to filter worktrees...", noMatchMessage: "No worktrees match your search", children: _jsx(SelectInput, { items: items, onSelect: raw => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, color: "green", children: ["CCManager - Claude Code Worktree Manager v", version] }), projectName && (_jsx(Text, { bold: true, color: "green", children: projectName }))] }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Select a worktree to start or resume a Claude Code session:" }) }), ((searchQuery && !isSearchMode) || stateFilter !== 'all') && (_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [searchQuery && !isSearchMode && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Filtered: " }), _jsxs(Text, { color: "cyan", bold: true, children: ["\"", searchQuery, "\""] })] })), stateFilter !== 'all' && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "State filter: " }), _jsx(Text, { color: "cyan", bold: true, children: getSessionStateFilterLabel(stateFilter) }), _jsx(Text, { dimColor: true, children: " (Tab to cycle, back to All clears it)" })] }))] })), _jsx(SearchableList, { isSearchMode: isSearchMode, searchQuery: searchQuery, onSearchQueryChange: setSearchQuery, selectedIndex: selectedIndex, items: items, limit: limit, placeholder: "Type to filter worktrees...", noMatchMessage: "No worktrees match your search", children: _jsx(SelectInput, { items: items, onSelect: raw => {
                         const item = items.find(i => i.value === raw?.value);
                         if (!item)
                             return;
@@ -445,7 +454,7 @@ const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentPro
                     }, isFocused: !error, initialIndex: selectedIndex, limit: limit }) }), (error || loadError) && (_jsx(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red", children: _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", bold: true, children: ["Error: ", error || loadError] }), _jsx(Text, { color: "gray", dimColor: true, children: "Press any key to dismiss" })] }) })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Status: ", STATUS_ICONS.BUSY, " ", STATUS_LABELS.BUSY, ' ', STATUS_ICONS.WAITING, " ", STATUS_LABELS.WAITING, " ", STATUS_ICONS.IDLE, ' ', STATUS_LABELS.IDLE, configReader.isAutoApprovalEnabled() && (_jsxs(_Fragment, { children: [' | ', _jsx(Text, { color: "green", children: "Auto Approval Enabled" })] }))] }), _jsx(Text, { dimColor: true, children: isSearchMode
                             ? 'Search Mode: Type to filter, Enter to exit search, ESC to exit search'
                             : searchQuery
-                                ? `Filtered: "${searchQuery}" | ↑↓ Navigate Enter Select | /-Search ESC-Clear 0-9 Quick Select Space-Session actions (session rows only) N-New M-Merge D-Delete ${configReader.isAutoApprovalEnabled() ? 'A-AutoApproval ' : ''}${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}`
-                                : `Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search Space-Session actions (session rows only) N-New M-Merge D-Delete ${configReader.isAutoApprovalEnabled() ? 'A-AutoApproval ' : ''}${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}` })] })] }));
+                                ? `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'}` })] })] }));
 };
 export default Menu;

package/dist/services/worktreeNameGenerator.js

@@ -12,6 +12,14 @@ const JSON_SCHEMA = JSON.stringify({
     additionalProperties: false,
 });
 const DEFAULT_TIMEOUT_MS = 30_000;
+// Generated branch names are short by construction. When `claude -p` returns
+// prose instead of a name (e.g. a refusal, or a request for an issue's
+// contents it cannot fetch), normalizing that text yields an unusually long,
+// many-segment slug. These bounds let us detect that case and reject it so the
+// caller falls back to a generated name instead of branching off a whole
+// sentence. They are also surfaced to the model in the prompt.
+const MAX_GENERATED_BRANCH_NAME_LENGTH = 60;
+const MAX_GENERATED_BRANCH_NAME_SEGMENTS = 10;
 const buildPrompt = (userPrompt, baseBranch) => `You generate concise git branch names.
 
 Base branch: ${baseBranch}
@@ -19,7 +27,10 @@ Task prompt:
 ${userPrompt}
 
 Return a short git branch name using lowercase letters, numbers, hyphens, and forward slashes only.
+Use at most ${MAX_GENERATED_BRANCH_NAME_SEGMENTS} hyphen- or slash-separated words and keep it under ${MAX_GENERATED_BRANCH_NAME_LENGTH} characters.
 Do not include markdown, explanations, refs/heads/, or surrounding quotes.
+Always output a branch name. Never refuse, never ask for clarification, and never request more information or access.
+If the task prompt references context you cannot access (for example an issue number, ticket, or URL), do not mention that limitation: just produce a best-effort name from the words available in the task prompt itself.
 Examples: feature/add-prompt-mode, fix/worktree-loading-state`;
 const normalizeBranchName = (branchName) => {
     const normalized = branchName
@@ -38,6 +49,13 @@ const normalizeBranchName = (branchName) => {
     if (!normalized) {
         throw new Error('Generated branch name was empty');
     }
+    if (normalized.length > MAX_GENERATED_BRANCH_NAME_LENGTH) {
+        throw new Error(`Generated branch name was too long (${normalized.length} > ${MAX_GENERATED_BRANCH_NAME_LENGTH} chars); treating it as invalid output`);
+    }
+    const segmentCount = normalized.split(/[/-]/).filter(Boolean).length;
+    if (segmentCount > MAX_GENERATED_BRANCH_NAME_SEGMENTS) {
+        throw new Error(`Generated branch name had too many words (${segmentCount} > ${MAX_GENERATED_BRANCH_NAME_SEGMENTS}); treating it as invalid output`);
+    }
     return normalized;
 };
 const extractStringCandidate = (value) => {

package/dist/services/worktreeNameGenerator.test.js

@@ -18,6 +18,18 @@ describe('WorktreeNameGenerator output parsing', () => {
         const value = extractBranchNameFromOutput('type":"result","subtype":"success","structured_output":{"branchName":"fix/trim-worktree-name"},"uuid":"123"');
         expect(value).toBe('fix/trim-worktree-name');
     });
+    it('rejects prose refusals that overflow the length budget', () => {
+        // `claude -p` sometimes puts a refusal sentence into the branchName field
+        // instead of a name; the caller relies on this throwing to use a fallback.
+        expect(() => extractBranchNameFromOutput('{"branchName":"i can t generate an informed branch name without understanding issue 310 could you either grant permission for webfetch or paste the issue description"}')).toThrow();
+    });
+    it('rejects names with too many words even when short', () => {
+        expect(() => extractBranchNameFromOutput('{"branchName":"a-b-c-d-e-f-g-h-i-j-k-l"}')).toThrow();
+    });
+    it('accepts a normal multi-word branch name', () => {
+        const value = extractBranchNameFromOutput('{"branchName":"feature/add-prompt-mode-toggle"}');
+        expect(value).toBe('feature/add-prompt-mode-toggle');
+    });
 });
 describe('deduplicateBranchName', () => {
     it('returns the name unchanged when no conflict exists', () => {

package/dist/utils/filterByQuery.d.ts

@@ -14,3 +14,28 @@ export declare function filterWorktreesByQuery(worktrees: Worktree[], query: str
  * sessions.
  */
 export declare function filterSessionItemsByQuery(items: SessionItem[], query: string): SessionItem[];
+/**
+ * The user-facing categories a session can be filtered by. `'all'` disables the
+ * filter. The four internal {@link SessionState} values collapse into three
+ * categories: `pending_auto_approval` is shown as `waiting` because it is a
+ * form of "waiting for the user" (mirrors the status display in statusIcons.ts).
+ */
+export type SessionStateFilter = 'all' | 'busy' | 'waiting' | 'idle';
+/**
+ * Order in which the Tab / Shift+Tab keys cycle the state filter.
+ * "Attention-first" so the states a user most often hunts for come up first.
+ */
+export declare const SESSION_STATE_FILTER_CYCLE: SessionStateFilter[];
+/**
+ * Filter session items by their current state. This is an independent dimension
+ * from {@link filterSessionItemsByQuery}: callers compose the two so a text
+ * query and a state filter can both be active at once.
+ *
+ * Rows without a session have no state, so they are excluded whenever a specific
+ * state (not `'all'`) is selected.
+ */
+export declare function filterSessionItemsByState(items: SessionItem[], filter: SessionStateFilter): SessionItem[];
+/** Advance the state filter one step in the cycle (Tab) or back (Shift+Tab). */
+export declare function cycleSessionStateFilter(current: SessionStateFilter, direction: 'next' | 'prev'): SessionStateFilter;
+/** Human-readable label (icon + word) for a state filter, used in the footer. */
+export declare function getSessionStateFilterLabel(filter: SessionStateFilter): string;

package/dist/utils/filterByQuery.js

@@ -1,3 +1,4 @@
+import { STATUS_ICONS, STATUS_LABELS } from '../constants/statusIcons.js';
 /**
  * Filter worktrees by matching search query against branch name and path.
  */
@@ -27,3 +28,64 @@ export function filterSessionItemsByQuery(items, query) {
     return items.filter(item => item.searchableName.toLowerCase().includes(searchLower) ||
         item.worktree.path.toLowerCase().includes(searchLower));
 }
+/**
+ * Order in which the Tab / Shift+Tab keys cycle the state filter.
+ * "Attention-first" so the states a user most often hunts for come up first.
+ */
+export const SESSION_STATE_FILTER_CYCLE = [
+    'all',
+    'busy',
+    'waiting',
+    'idle',
+];
+/** Map an internal session state onto its user-facing filter category. */
+function stateToFilterCategory(state) {
+    switch (state) {
+        case 'busy':
+            return 'busy';
+        case 'waiting_input':
+        case 'pending_auto_approval':
+            return 'waiting';
+        case 'idle':
+            return 'idle';
+    }
+}
+/**
+ * Filter session items by their current state. This is an independent dimension
+ * from {@link filterSessionItemsByQuery}: callers compose the two so a text
+ * query and a state filter can both be active at once.
+ *
+ * Rows without a session have no state, so they are excluded whenever a specific
+ * state (not `'all'`) is selected.
+ */
+export function filterSessionItemsByState(items, filter) {
+    if (filter === 'all')
+        return items;
+    return items.filter(item => {
+        const stateData = item.session?.stateMutex.getSnapshot();
+        if (!stateData)
+            return false;
+        return stateToFilterCategory(stateData.state) === filter;
+    });
+}
+/** Advance the state filter one step in the cycle (Tab) or back (Shift+Tab). */
+export function cycleSessionStateFilter(current, direction) {
+    const cycle = SESSION_STATE_FILTER_CYCLE;
+    const index = cycle.indexOf(current);
+    const offset = direction === 'next' ? 1 : -1;
+    const nextIndex = (index + offset + cycle.length) % cycle.length;
+    return cycle[nextIndex];
+}
+/** Human-readable label (icon + word) for a state filter, used in the footer. */
+export function getSessionStateFilterLabel(filter) {
+    switch (filter) {
+        case 'all':
+            return 'All';
+        case 'busy':
+            return `${STATUS_ICONS.BUSY} ${STATUS_LABELS.BUSY}`;
+        case 'waiting':
+            return `${STATUS_ICONS.WAITING} ${STATUS_LABELS.WAITING}`;
+        case 'idle':
+            return `${STATUS_ICONS.IDLE} ${STATUS_LABELS.IDLE}`;
+    }
+}

package/dist/utils/filterByQuery.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
-import { filterWorktreesByQuery, filterSessionItemsByQuery, } from './filterByQuery.js';
+import { filterWorktreesByQuery, filterSessionItemsByQuery, filterSessionItemsByState, cycleSessionStateFilter, getSessionStateFilterLabel, } from './filterByQuery.js';
+import { STATUS_ICONS, STATUS_LABELS } from '../constants/statusIcons.js';
 const makeItem = (searchableName, path) => ({
     worktree: {
         path,
@@ -20,6 +21,14 @@ const makeItem = (searchableName, path) => ({
         lastCommitDate: 0,
     },
 });
+// Minimal session stub exposing only what filterSessionItemsByState reads:
+// stateMutex.getSnapshot().state.
+const makeItemWithState = (searchableName, path, state) => ({
+    ...makeItem(searchableName, path),
+    session: {
+        stateMutex: { getSnapshot: () => ({ state }) },
+    },
+});
 describe('filterWorktreesByQuery', () => {
     const worktrees = [
         {
@@ -79,3 +88,59 @@ describe('filterSessionItemsByQuery', () => {
         expect(result).toHaveLength(2);
     });
 });
+describe('filterSessionItemsByState', () => {
+    const items = [
+        makeItemWithState('busy-a', '/repo/busy-a', 'busy'),
+        makeItemWithState('waiting-a', '/repo/waiting-a', 'waiting_input'),
+        makeItemWithState('pending-a', '/repo/pending-a', 'pending_auto_approval'),
+        makeItemWithState('idle-a', '/repo/idle-a', 'idle'),
+        // A worktree row with no running session (no state).
+        makeItem('no-session', '/repo/no-session'),
+    ];
+    it('returns all items when the filter is "all"', () => {
+        expect(filterSessionItemsByState(items, 'all')).toEqual(items);
+    });
+    it('keeps only busy sessions', () => {
+        const result = filterSessionItemsByState(items, 'busy');
+        expect(result.map(i => i.searchableName)).toEqual(['busy-a']);
+    });
+    it('folds pending_auto_approval into the waiting category', () => {
+        const result = filterSessionItemsByState(items, 'waiting');
+        expect(result.map(i => i.searchableName)).toEqual([
+            'waiting-a',
+            'pending-a',
+        ]);
+    });
+    it('keeps only idle sessions', () => {
+        const result = filterSessionItemsByState(items, 'idle');
+        expect(result.map(i => i.searchableName)).toEqual(['idle-a']);
+    });
+    it('excludes rows without a session for any specific state', () => {
+        for (const filter of ['busy', 'waiting', 'idle']) {
+            const result = filterSessionItemsByState(items, filter);
+            expect(result.map(i => i.searchableName)).not.toContain('no-session');
+        }
+    });
+});
+describe('cycleSessionStateFilter', () => {
+    it('cycles forward all -> busy -> waiting -> idle -> all', () => {
+        expect(cycleSessionStateFilter('all', 'next')).toBe('busy');
+        expect(cycleSessionStateFilter('busy', 'next')).toBe('waiting');
+        expect(cycleSessionStateFilter('waiting', 'next')).toBe('idle');
+        expect(cycleSessionStateFilter('idle', 'next')).toBe('all');
+    });
+    it('cycles backward all -> idle -> waiting -> busy -> all', () => {
+        expect(cycleSessionStateFilter('all', 'prev')).toBe('idle');
+        expect(cycleSessionStateFilter('idle', 'prev')).toBe('waiting');
+        expect(cycleSessionStateFilter('waiting', 'prev')).toBe('busy');
+        expect(cycleSessionStateFilter('busy', 'prev')).toBe('all');
+    });
+});
+describe('getSessionStateFilterLabel', () => {
+    it('labels each filter with icon and word', () => {
+        expect(getSessionStateFilterLabel('all')).toBe('All');
+        expect(getSessionStateFilterLabel('busy')).toBe(`${STATUS_ICONS.BUSY} ${STATUS_LABELS.BUSY}`);
+        expect(getSessionStateFilterLabel('waiting')).toBe(`${STATUS_ICONS.WAITING} ${STATUS_LABELS.WAITING}`);
+        expect(getSessionStateFilterLabel('idle')).toBe(`${STATUS_ICONS.IDLE} ${STATUS_LABELS.IDLE}`);
+    });
+});

package/dist/utils/worktreeUtils.d.ts

@@ -25,7 +25,31 @@ export interface SessionItem {
  */
 export declare function formatRelativeDate(date: Date): string;
 export declare function truncateString(str: string, maxLength: number): string;
+/**
+ * Sanitize a branch name into the form used for a worktree directory name:
+ * slashes become dashes, characters outside [a-zA-Z0-9-_.] are stripped,
+ * leading/trailing dashes are removed, and the result is lowercased.
+ *
+ * This is the single source of truth for that mapping. It is reused both to
+ * generate worktree directories (see {@link generateWorktreeDirectory}) and to
+ * decide whether an existing directory name already conveys the branch name
+ * (see {@link formatWorktreeDirectorySuffix}), so a directory generated from a
+ * branch is reliably recognized as a match.
+ */
+export declare function sanitizeNameForDirectory(value: string): string;
 export declare function generateWorktreeDirectory(projectPath: string, branchName: string, pattern?: string): string;
+/**
+ * Returns the worktree directory basename to show alongside the branch name,
+ * or an empty string when it would be redundant (main worktree, detached,
+ * or the directory name matches the branch).
+ *
+ * The visible suffix is truncated; the raw basename is also returned so
+ * callers that want to make it searchable can include it untruncated.
+ */
+export declare function formatWorktreeDirectorySuffix(wt: Worktree, fullBranchName: string): {
+    displaySuffix: string;
+    rawName: string;
+};
 export declare function extractBranchParts(branchName: string): {
     prefix?: string;
     name: string;

package/dist/utils/worktreeUtils.js

@@ -5,6 +5,7 @@ import { getStatusDisplay } from '../constants/statusIcons.js';
 import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from './gitStatus.js';
 // Constants
 const MAX_BRANCH_NAME_LENGTH = 70; // Maximum characters for branch name display
+const MAX_WORKTREE_DIR_NAME_LENGTH = 30; // Maximum characters for the worktree directory name suffix
 const MIN_COLUMN_PADDING = 2; // Minimum spaces between columns
 /**
  * Format a date as a relative time string (e.g., "2h ago", "3d ago").
@@ -64,6 +65,24 @@ function getGitRepositoryName(projectPath) {
         return path.basename(projectPath);
     }
 }
+/**
+ * Sanitize a branch name into the form used for a worktree directory name:
+ * slashes become dashes, characters outside [a-zA-Z0-9-_.] are stripped,
+ * leading/trailing dashes are removed, and the result is lowercased.
+ *
+ * This is the single source of truth for that mapping. It is reused both to
+ * generate worktree directories (see {@link generateWorktreeDirectory}) and to
+ * decide whether an existing directory name already conveys the branch name
+ * (see {@link formatWorktreeDirectorySuffix}), so a directory generated from a
+ * branch is reliably recognized as a match.
+ */
+export function sanitizeNameForDirectory(value) {
+    return value
+        .replace(/\//g, '-') // Replace forward slashes with dashes
+        .replace(/[^a-zA-Z0-9-_.]+/g, '') // Remove special characters except dash, dot, underscore
+        .replace(/^-+|-+$/g, '') // Remove leading/trailing dashes
+        .toLowerCase(); // Convert to lowercase for consistency
+}
 export function generateWorktreeDirectory(projectPath, branchName, pattern) {
     // Default pattern if not specified
     const defaultPattern = '../{branch}';
@@ -74,12 +93,7 @@ export function generateWorktreeDirectory(projectPath, branchName, pattern) {
         switch (name) {
             case 'branch':
             case 'branch-name':
-                // Sanitize branch name for filesystem
-                sanitizedBranch ??= branchName
-                    .replace(/\//g, '-') // Replace forward slashes with dashes
-                    .replace(/[^a-zA-Z0-9-_.]+/g, '') // Remove special characters except dash, dot, underscore
-                    .replace(/^-+|-+$/g, '') // Remove leading/trailing dashes
-                    .toLowerCase(); // Convert to lowercase for consistency
+                sanitizedBranch ??= sanitizeNameForDirectory(branchName);
                 return sanitizedBranch;
             case 'project':
                 projectName ??= getGitRepositoryName(projectPath);
@@ -91,6 +105,40 @@ export function generateWorktreeDirectory(projectPath, branchName, pattern) {
     // Ensure the path is relative to the repository root
     return path.normalize(directory);
 }
+/**
+ * Returns the worktree directory basename to show alongside the branch name,
+ * or an empty string when it would be redundant (main worktree, detached,
+ * or the directory name matches the branch).
+ *
+ * The visible suffix is truncated; the raw basename is also returned so
+ * callers that want to make it searchable can include it untruncated.
+ */
+export function formatWorktreeDirectorySuffix(wt, fullBranchName) {
+    if (wt.isMainWorktree)
+        return { displaySuffix: '', rawName: '' };
+    if (!wt.branch)
+        return { displaySuffix: '', rawName: '' };
+    if (!wt.path)
+        return { displaySuffix: '', rawName: '' };
+    const dirName = path.basename(wt.path);
+    if (!dirName)
+        return { displaySuffix: '', rawName: '' };
+    const normalizedDir = sanitizeNameForDirectory(dirName);
+    if (!normalizedDir)
+        return { displaySuffix: '', rawName: '' };
+    const normalizedBranch = sanitizeNameForDirectory(fullBranchName);
+    if (normalizedDir === normalizedBranch) {
+        return { displaySuffix: '', rawName: '' };
+    }
+    // Also suppress when the directory matches just the tail segment of the
+    // branch (e.g. branch "feature/foo" vs directory "foo").
+    const tail = extractBranchParts(fullBranchName).name;
+    if (tail && sanitizeNameForDirectory(tail) === normalizedDir) {
+        return { displaySuffix: '', rawName: '' };
+    }
+    const visible = truncateString(dirName, MAX_WORKTREE_DIR_NAME_LENGTH);
+    return { displaySuffix: ` @ ${visible}`, rawName: dirName };
+}
 export function extractBranchParts(branchName) {
     const parts = branchName.split('/');
     if (parts.length > 1) {
@@ -165,10 +213,12 @@ function buildSessionItem(wt, session, sessionSuffix) {
         : 'detached';
     const branchName = truncateString(fullBranchName, MAX_BRANCH_NAME_LENGTH);
     const isMain = wt.isMainWorktree ? ' (main)' : '';
-    const baseLabel = `${branchName}${isMain}${sessionSuffix}${status}`;
+    const { displaySuffix: dirSuffix, rawName: rawDirName } = formatWorktreeDirectorySuffix(wt, fullBranchName);
+    const baseLabel = `${branchName}${dirSuffix}${isMain}${sessionSuffix}${status}`;
     // Use the full (untruncated) branch name so search still matches the tail
     // of long branch names; status icons are excluded so they don't match.
-    const searchableName = `${fullBranchName}${isMain}${sessionSuffix}`;
+    const rawDirForSearch = rawDirName ? ` @ ${rawDirName}` : '';
+    const searchableName = `${fullBranchName}${rawDirForSearch}${isMain}${sessionSuffix}`;
     const { fileChanges, aheadBehind, parentBranch, error } = gitStatusColumns(wt, fullBranchName);
     const lastCommitDate = wt.lastCommitDate
         ? `\x1b[90m${formatRelativeDate(wt.lastCommitDate)}\x1b[0m`

package/dist/utils/worktreeUtils.test.js

@@ -113,8 +113,10 @@ describe('truncateString', () => {
     });
 });
 describe('prepareSessionItems', () => {
+    // The directory basename here matches the sanitized branch tail so the
+    // worktree-directory suffix is suppressed in the basic baseLabel tests.
     const mockWorktree = {
-        path: '/path/to/worktree',
+        path: '/path/to/test-branch',
         branch: 'feature/test-branch',
         isMainWorktree: false,
         hasSession: false,
@@ -122,7 +124,7 @@ describe('prepareSessionItems', () => {
     // Simplified mock
     const mockSession = {
         id: 'test-session',
-        worktreePath: '/path/to/worktree',
+        worktreePath: '/path/to/test-branch',
         sessionNumber: 1,
         command: 'claude',
         fallbackArgs: undefined,
@@ -167,6 +169,108 @@ describe('prepareSessionItems', () => {
         const items = prepareSessionItems([longBranch], []);
         expect(items[0]?.baseLabel.length).toBeLessThanOrEqual(80); // 70 + status + default
     });
+    describe('worktree directory suffix', () => {
+        it('shows the directory name when it differs from the branch', () => {
+            const wt = {
+                path: '/repos/myproj/worktrees/login-api',
+                branch: 'feature/login',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            expect(items[0]?.baseLabel).toBe('feature/login @ login-api');
+        });
+        it('hides the directory name when the directory equals the branch tail', () => {
+            const wt = {
+                path: '/repos/myproj/worktrees/foo',
+                branch: 'feature/foo',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            expect(items[0]?.baseLabel).toBe('feature/foo');
+        });
+        it('hides the directory name when it matches the sanitized full branch', () => {
+            const wt = {
+                path: '/repos/myproj/worktrees/feature-foo',
+                branch: 'feature/foo',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            expect(items[0]?.baseLabel).toBe('feature/foo');
+        });
+        it('hides the directory name for the main worktree', () => {
+            const wt = {
+                path: '/repos/myproj',
+                branch: 'main',
+                isMainWorktree: true,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            expect(items[0]?.baseLabel).toBe('main (main)');
+        });
+        it('truncates long directory names in the displayed label', () => {
+            const longDir = '/repos/myproj/worktrees/this-is-a-very-long-directory-name-that-should-be-truncated';
+            const wt = {
+                path: longDir,
+                branch: 'feature/short',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            // "feature/short @ " (16 chars) + up to MAX_WORKTREE_DIR_NAME_LENGTH (30)
+            const after = items[0]?.baseLabel.split(' @ ')[1] ?? '';
+            expect(after.length).toBeLessThanOrEqual(30);
+            expect(after.endsWith('...')).toBe(true);
+        });
+        it('keeps the untruncated directory basename in searchableName', () => {
+            const longDir = '/repos/myproj/worktrees/this-is-a-very-long-directory-name-that-should-be-truncated';
+            const wt = {
+                path: longDir,
+                branch: 'feature/short',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], []);
+            expect(items[0]?.searchableName).toContain('this-is-a-very-long-directory-name-that-should-be-truncated');
+        });
+        it('places the directory suffix before session and status markers', () => {
+            const wt = {
+                path: '/repos/myproj/worktrees/foo-api',
+                branch: 'feature/foo',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const items = prepareSessionItems([wt], [
+                {
+                    ...mockSession,
+                    worktreePath: '/repos/myproj/worktrees/foo-api',
+                    sessionName: 'lab',
+                },
+            ]);
+            // Order must be: branch, dir suffix, (no main), session suffix, status.
+            expect(items[0]?.baseLabel).toMatch(/^feature\/foo @ foo-api: lab \[.*Idle.*\]$/);
+        });
+        it('does not break column alignment when a dir suffix is appended', () => {
+            const items = prepareSessionItems([
+                {
+                    path: '/repos/myproj/worktrees/foo-api',
+                    branch: 'feature/foo',
+                    isMainWorktree: false,
+                    hasSession: false,
+                },
+                {
+                    path: '/repos/myproj',
+                    branch: 'main',
+                    isMainWorktree: true,
+                    hasSession: false,
+                },
+            ], []);
+            expect(items[0]?.lengths.base).toBe(items[0]?.baseLabel.length);
+            expect(items[1]?.lengths.base).toBe(items[1]?.baseLabel.length);
+        });
+    });
 });
 describe('column alignment', () => {
     const mockItems = [

package/package.json

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