ccmanager 3.11.3 → 3.12.1

package/dist/components/Dashboard.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useState, useEffect, useMemo } from 'react';
-import { Box, Text, useInput, useStdout } from 'ink';
+import { Box, Text, useInput } from 'ink';
 import { Effect } from 'effect';
 import SelectInput from 'ink-select-input';
 import stripAnsi from 'strip-ansi';
@@ -10,10 +10,11 @@ import { SessionManager } from '../services/sessionManager.js';
 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 { useGitStatus } from '../hooks/useGitStatus.js';
 import { truncateString, calculateColumnPositions, assembleWorktreeLabel, formatRelativeDate, } from '../utils/worktreeUtils.js';
 import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from '../utils/gitStatus.js';
-import TextInputWrapper from './TextInputWrapper.js';
+import SearchableList from './SearchableList.js';
 const MAX_BRANCH_NAME_LENGTH = 70;
 const createSeparatorWithText = (text, totalWidth = 35) => {
     const textWithSpaces = ` ${text} `;
@@ -72,14 +73,15 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
     const [sessionEntries, setSessionEntries] = useState([]);
     const [baseSessionWorktrees, setBaseSessionWorktrees] = useState([]);
     const [sessionRefreshKey, setSessionRefreshKey] = useState(0);
-    const { stdout } = useStdout();
-    const fixedRows = 6;
     const displayError = error || loadError;
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
         isDisabled: !!displayError,
         skipInTest: false,
     });
-    const limit = Math.max(5, stdout.rows - fixedRows - (isSearchMode ? 1 : 0) - (displayError ? 3 : 0));
+    const limit = useDynamicLimit({
+        isSearchMode,
+        hasError: !!displayError,
+    });
     // Git status polling for session worktrees
     const enrichedWorktrees = useGitStatus(baseSessionWorktrees, baseSessionWorktrees.length > 0 ? 'main' : null);
     // Discover projects on mount
@@ -440,7 +442,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
             });
         }
     };
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, flexDirection: "column", children: _jsxs(Text, { bold: true, color: "green", children: ["CCManager - Dashboard v", version] }) }), isSearchMode && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter..." })] })), loading ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "Discovering projects..." }) })) : projects.length === 0 && !displayError ? (_jsx(Box, { children: _jsxs(Text, { color: "yellow", children: ["No git repositories found in ", projectsDir] }) })) : isSearchMode && items.length === 0 ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "No matches found" }) })) : isSearchMode ? (_jsx(Box, { flexDirection: "column", children: items.slice(0, limit).map((item, index) => (_jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', item.label] }, item.value))) })) : (_jsx(SelectInput, { items: items, onSelect: item => handleSelect(item), isFocused: !displayError, limit: limit, initialIndex: selectedIndex })), displayError && (_jsx(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red", children: _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", bold: true, children: ["Error: ", displayError] }), _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] }), _jsx(Text, { dimColor: true, children: isSearchMode
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, flexDirection: "column", children: _jsxs(Text, { bold: true, color: "green", children: ["CCManager - Dashboard v", version] }) }), loading ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "Discovering projects..." }) })) : projects.length === 0 && !displayError ? (_jsx(Box, { children: _jsxs(Text, { color: "yellow", children: ["No git repositories found in ", projectsDir] }) })) : (_jsx(SearchableList, { isSearchMode: isSearchMode, searchQuery: searchQuery, onSearchQueryChange: setSearchQuery, selectedIndex: selectedIndex, items: items, limit: limit, placeholder: "Type to filter...", noMatchMessage: "No matches found", children: _jsx(SelectInput, { items: items, onSelect: item => handleSelect(item), isFocused: !displayError, limit: limit, initialIndex: selectedIndex }) })), displayError && (_jsx(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red", children: _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", bold: true, children: ["Error: ", displayError] }), _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] }), _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 R-Refresh Q-Quit`

package/dist/components/DeleteWorktree.js

@@ -7,6 +7,10 @@ import { Effect } from 'effect';
 import { WorktreeService } from '../services/worktreeService.js';
 import DeleteConfirmation from './DeleteConfirmation.js';
 import { shortcutManager } from '../services/shortcutManager.js';
+import { useSearchMode } from '../hooks/useSearchMode.js';
+import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
+import { filterWorktreesByQuery } from '../utils/filterByQuery.js';
+import SearchableList from './SearchableList.js';
 const DeleteWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const [worktrees, setWorktrees] = useState([]);
     const [selectedIndices, setSelectedIndices] = useState(new Set());
@@ -14,6 +18,15 @@ const DeleteWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const [focusedIndex, setFocusedIndex] = useState(0);
     const [error, setError] = useState(null);
     const [isLoading, setIsLoading] = useState(true);
+    const [menuItems, setMenuItems] = useState([]);
+    // Use the search mode hook
+    const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(menuItems.length, {
+        isDisabled: confirmMode,
+    });
+    const limit = useDynamicLimit({
+        isSearchMode,
+        hasError: !!error,
+    });
     useEffect(() => {
         let cancelled = false;
         const loadWorktrees = async () => {
@@ -49,17 +62,22 @@ const DeleteWorktree = ({ projectPath, onComplete, onCancel, }) => {
             cancelled = true;
         };
     }, [projectPath]);
-    // Create menu items from worktrees
-    const menuItems = worktrees.map((worktree, index) => {
-        const branchName = worktree.branch
-            ? worktree.branch.replace('refs/heads/', '')
-            : 'detached';
-        const isSelected = selectedIndices.has(index);
-        return {
-            label: `${isSelected ? '[✓]' : '[ ]'} ${branchName} (${worktree.path})`,
-            value: index.toString(),
-        };
-    });
+    // Build menu items from worktrees, filtering by search query
+    useEffect(() => {
+        const filteredWorktrees = filterWorktreesByQuery(worktrees, searchQuery);
+        const items = filteredWorktrees.map(worktree => {
+            const originalIndex = worktrees.indexOf(worktree);
+            const branchName = worktree.branch
+                ? worktree.branch.replace('refs/heads/', '')
+                : 'detached';
+            const isSelected = selectedIndices.has(originalIndex);
+            return {
+                label: `${isSelected ? '[✓]' : '[ ]'} ${branchName} (${worktree.path})`,
+                value: originalIndex.toString(),
+            };
+        });
+        setMenuItems(items);
+    }, [worktrees, searchQuery, selectedIndices]);
     const handleSelect = (item) => {
         // Don't toggle on Enter - this will be used to confirm
         // We'll handle Space key separately for toggling
@@ -71,6 +89,10 @@ const DeleteWorktree = ({ projectPath, onComplete, onCancel, }) => {
             // Confirmation component handles input
             return;
         }
+        // Don't process other keys if in search mode (handled by useSearchMode)
+        if (isSearchMode) {
+            return;
+        }
         if (input === ' ') {
             // Toggle selection on space
             setSelectedIndices(prev => {
@@ -111,13 +133,14 @@ const DeleteWorktree = ({ projectPath, onComplete, onCancel, }) => {
         };
         return (_jsx(DeleteConfirmation, { worktrees: selectedWorktrees, onConfirm: handleConfirm, onCancel: handleCancel }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "red", children: "Delete Worktrees" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Select worktrees to delete (Space to select, Enter to confirm):" }) }), _jsx(SelectInput, { items: menuItems, onSelect: handleSelect, onHighlight: (item) => {
-                    const index = parseInt(item.value, 10);
-                    setFocusedIndex(index);
-                }, limit: 10, indicatorComponent: ({ isSelected }) => (_jsx(Text, { color: isSelected ? 'green' : undefined, children: isSelected ? '>' : ' ' })), itemComponent: ({ isSelected, label }) => {
-                    // Check if this item is actually selected (checkbox checked)
-                    const hasCheckmark = label.includes('[✓]');
-                    return (_jsx(Text, { color: isSelected ? 'green' : undefined, inverse: isSelected, dimColor: !isSelected && !hasCheckmark, children: label }));
-                } }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Controls: \u2191\u2193/j/k Navigate, Space Select, Enter Confirm,", ' ', shortcutManager.getShortcutDisplay('cancel'), " Cancel"] }), selectedIndices.size > 0 && (_jsxs(Text, { color: "yellow", children: [selectedIndices.size, " worktree", selectedIndices.size > 1 ? 's' : '', ' ', "selected"] }))] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "red", children: "Delete Worktrees" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Select worktrees to delete (Space to select, Enter to confirm):" }) }), _jsx(SearchableList, { isSearchMode: isSearchMode, searchQuery: searchQuery, onSearchQueryChange: setSearchQuery, selectedIndex: selectedIndex, items: menuItems, limit: limit, placeholder: "Type to filter worktrees...", noMatchMessage: "No worktrees match your search", children: _jsx(SelectInput, { items: menuItems, onSelect: handleSelect, onHighlight: (item) => {
+                        const index = parseInt(item.value, 10);
+                        setFocusedIndex(index);
+                    }, limit: limit, indicatorComponent: ({ isSelected }) => (_jsx(Text, { color: isSelected ? 'green' : undefined, children: isSelected ? '>' : ' ' })), itemComponent: ({ isSelected, label }) => {
+                        const hasCheckmark = label.includes('[✓]');
+                        return (_jsx(Text, { color: isSelected ? 'green' : undefined, inverse: isSelected, dimColor: !isSelected && !hasCheckmark, children: label }));
+                    } }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: isSearchMode
+                            ? 'Search Mode: Type to filter, Enter to exit search, ESC to exit search'
+                            : `Controls: ↑↓/j/k Navigate, Space Select, Enter Confirm, /-Search, ${shortcutManager.getShortcutDisplay('cancel')} Cancel` }), selectedIndices.size > 0 && (_jsxs(Text, { color: "yellow", children: [selectedIndices.size, " worktree", selectedIndices.size > 1 ? 's' : '', ' ', "selected"] }))] })] }));
 };
 export default DeleteWorktree;

package/dist/components/Menu.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { useState, useEffect } from 'react';
-import { Box, Text, useInput, useStdout } from 'ink';
+import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import { Effect } from 'effect';
 import { SessionManager } from '../services/sessionManager.js';
@@ -8,8 +8,10 @@ import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, } from '../constants/statusIco
 import { useGitStatus } from '../hooks/useGitStatus.js';
 import { prepareWorktreeItems, calculateColumnPositions, assembleWorktreeLabel, } from '../utils/worktreeUtils.js';
 import { projectManager } from '../services/projectManager.js';
-import TextInputWrapper from './TextInputWrapper.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
+import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
+import { filterWorktreesByQuery } from '../utils/filterByQuery.js';
+import SearchableList from './SearchableList.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { configReader } from '../services/config/configReader.js';
 const createSeparatorWithText = (text, totalWidth = 35) => {
@@ -37,16 +39,14 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
     const [recentProjects, setRecentProjects] = useState([]);
     const [highlightedWorktreePath, setHighlightedWorktreePath] = useState(null);
     const [autoApprovalToggleCounter, setAutoApprovalToggleCounter] = useState(0);
-    const { stdout } = useStdout();
-    const fixedRows = 6;
     // Use the search mode hook
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
         isDisabled: !!error || !!loadError,
     });
-    const limit = Math.max(5, stdout.rows -
-        fixedRows -
-        (isSearchMode ? 1 : 0) -
-        (error || loadError ? 3 : 0));
+    const limit = useDynamicLimit({
+        isSearchMode,
+        hasError: !!(error || loadError),
+    });
     // Get worktree configuration for sorting
     const worktreeConfig = configReader.getWorktreeConfig();
     useEffect(() => {
@@ -129,14 +129,9 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
         const items = prepareWorktreeItems(worktrees, sessions);
         const columnPositions = calculateColumnPositions(items);
         // Filter worktrees based on search query
-        const filteredItems = searchQuery
-            ? items.filter(item => {
-                const branchName = item.worktree.branch || '';
-                const searchLower = searchQuery.toLowerCase();
-                return (branchName.toLowerCase().includes(searchLower) ||
-                    item.worktree.path.toLowerCase().includes(searchLower));
-            })
-            : items;
+        const filteredWorktrees = filterWorktreesByQuery(items.map(item => item.worktree), searchQuery);
+        const filteredWorktreeSet = new Set(filteredWorktrees);
+        const filteredItems = items.filter(item => filteredWorktreeSet.has(item.worktree));
         // Build menu items with proper alignment
         const menuItems = filteredItems.map((item, index) => {
             const baseLabel = assembleWorktreeLabel(item, columnPositions);
@@ -510,19 +505,17 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             onSelectWorktree(item.worktree);
         }
     };
-    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:" }) }), isSearchMode && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter worktrees..." })] })), isSearchMode && items.length === 0 ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "No worktrees match your search" }) })) : isSearchMode ? (
-            // In search mode, show the items as a list without SelectInput
-            _jsx(Box, { flexDirection: "column", children: items.slice(0, limit).map((item, index) => (_jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', item.label] }, item.value))) })) : (_jsx(SelectInput, { items: items, onSelect: item => handleSelect(item), onHighlight: item => {
-                    // ink-select-input may call onHighlight with undefined when items are empty
-                    // (e.g., during menu re-mount after returning from a session), so guard it.
-                    if (!item) {
-                        return;
-                    }
-                    const menuItem = item;
-                    if (menuItem.type === 'worktree') {
-                        setHighlightedWorktreePath(menuItem.worktree.path);
-                    }
-                }, 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
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, color: "green", children: ["CCManager - Claude Code Worktree Manager v", version] }), projectName && (_jsx(Text, { bold: true, color: "green", children: projectName }))] }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Select a worktree to start or resume a Claude Code session:" }) }), _jsx(SearchableList, { isSearchMode: isSearchMode, searchQuery: searchQuery, onSearchQueryChange: setSearchQuery, selectedIndex: selectedIndex, items: items, limit: limit, placeholder: "Type to filter worktrees...", noMatchMessage: "No worktrees match your search", children: _jsx(SelectInput, { items: items, onSelect: item => handleSelect(item), onHighlight: item => {
+                        // ink-select-input may call onHighlight with undefined when items are empty
+                        // (e.g., during menu re-mount after returning from a session), so guard it.
+                        if (!item) {
+                            return;
+                        }
+                        const menuItem = item;
+                        if (menuItem.type === 'worktree') {
+                            setHighlightedWorktreePath(menuItem.worktree.path);
+                        }
+                    }, isFocused: !error, initialIndex: selectedIndex, limit: limit }) }), (error || loadError) && (_jsx(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red", children: _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", bold: true, children: ["Error: ", error || loadError] }), _jsx(Text, { color: "gray", dimColor: true, children: "Press any key to dismiss" })] }) })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Status: ", STATUS_ICONS.BUSY, " ", STATUS_LABELS.BUSY, ' ', STATUS_ICONS.WAITING, " ", STATUS_LABELS.WAITING, " ", STATUS_ICONS.IDLE, ' ', STATUS_LABELS.IDLE, configReader.isAutoApprovalEnabled() && (_jsxs(_Fragment, { children: [' | ', _jsx(Text, { color: "green", children: "Auto Approval Enabled" })] }))] }), _jsx(Text, { dimColor: true, children: isSearchMode
                             ? 'Search Mode: Type to filter, Enter to exit search, ESC to exit search'
                             : searchQuery
                                 ? `Filtered: "${searchQuery}" | ↑↓ Navigate Enter Select | /-Search ESC-Clear 0-9 Quick Select N-New M-Merge D-Delete ${configReader.isAutoApprovalEnabled() ? 'A-AutoApproval ' : ''}${multiProject ? 'C-Config' : 'P-ProjConfig C-GlobalConfig'} ${projectName ? 'B-Back' : 'Q-Quit'}`

package/dist/components/NewWorktree.js

@@ -8,6 +8,7 @@ import { configReader } from '../services/config/configReader.js';
 import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
+import SearchableList from './SearchableList.js';
 import { Effect } from 'effect';
 import { describePromptInjection, getPromptInjectionMethod, } from '../utils/presetPrompt.js';
 const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
@@ -238,7 +239,7 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const promptMethod = selectedPreset
         ? getPromptInjectionMethod(selectedPreset)
         : 'stdin';
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), step === 'path' && !isAutoDirectory ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter worktree path (relative to repository root):" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })] })] })) : null, step === 'base-branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select base branch for the worktree:" }) }), isSearchMode && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter branches..." })] })), isSearchMode && branchItems.length === 0 ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "No branches match your search" }) })) : isSearchMode ? (_jsx(Box, { flexDirection: "column", children: branchItems.slice(0, limit).map((item, index) => (_jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', item.label] }, item.value))) })) : (_jsx(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode })), !isSearchMode && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press / to search" }) }))] })), step === 'creation-mode' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "How do you want to create the new worktree?" }) }), _jsx(SelectInput, { items: [
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), step === 'path' && !isAutoDirectory ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter worktree path (relative to repository root):" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })] })] })) : null, step === 'base-branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select base branch for the worktree:" }) }), _jsx(SearchableList, { isSearchMode: isSearchMode, searchQuery: searchQuery, onSearchQueryChange: setSearchQuery, selectedIndex: selectedIndex, items: branchItems, limit: limit, placeholder: "Type to filter branches...", noMatchMessage: "No branches match your search", children: _jsx(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode }) }), !isSearchMode && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press / to search" }) }))] })), step === 'creation-mode' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "How do you want to create the new worktree?" }) }), _jsx(SelectInput, { items: [
                             {
                                 label: '1. Choose the branch name yourself',
                                 value: 'manual',

package/dist/components/SearchableList.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+interface ListItem {
+    label: string;
+    value: string;
+}
+interface SearchableListProps {
+    isSearchMode: boolean;
+    searchQuery: string;
+    onSearchQueryChange: (query: string) => void;
+    selectedIndex: number;
+    items: ListItem[];
+    limit: number;
+    placeholder?: string;
+    noMatchMessage?: string;
+    children: React.ReactNode;
+}
+/**
+ * Shared search mode UI: search input, filtered result list, and no-match message.
+ * Wraps a SelectInput (passed as children) which is shown when not in search mode.
+ */
+declare const SearchableList: React.FC<SearchableListProps>;
+export default SearchableList;

package/dist/components/SearchableList.js

@@ -0,0 +1,14 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import TextInputWrapper from './TextInputWrapper.js';
+/**
+ * Shared search mode UI: search input, filtered result list, and no-match message.
+ * Wraps a SelectInput (passed as children) which is shown when not in search mode.
+ */
+const SearchableList = ({ isSearchMode, searchQuery, onSearchQueryChange, selectedIndex, items, limit, placeholder = 'Type to filter...', noMatchMessage = 'No matches found', children, }) => {
+    if (!isSearchMode) {
+        return _jsx(_Fragment, { children: children });
+    }
+    return (_jsxs(_Fragment, { children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(TextInputWrapper, { value: searchQuery, onChange: onSearchQueryChange, focus: true, placeholder: placeholder })] }), items.length === 0 ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: noMatchMessage }) })) : (_jsx(Box, { flexDirection: "column", children: items.slice(0, limit).map((item, index) => (_jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', item.label] }, item.value))) }))] }));
+};
+export default SearchableList;

package/dist/constants/statePersistence.d.ts

@@ -1,2 +1,3 @@
 export declare const STATE_PERSISTENCE_DURATION_MS = 200;
 export declare const STATE_CHECK_INTERVAL_MS = 100;
+export declare const STATE_MINIMUM_DURATION_MS = 500;

package/dist/constants/statePersistence.js

@@ -2,3 +2,5 @@
 export const STATE_PERSISTENCE_DURATION_MS = 200;
 // Check interval for state detection in milliseconds
 export const STATE_CHECK_INTERVAL_MS = 100;
+// Minimum duration in current state before allowing transition to a new state
+export const STATE_MINIMUM_DURATION_MS = 500;

package/dist/hooks/useDynamicLimit.d.ts

@@ -0,0 +1,10 @@
+interface UseDynamicLimitOptions {
+    fixedRows?: number;
+    isSearchMode?: boolean;
+    hasError?: boolean;
+}
+/**
+ * Calculate the maximum number of list items to display based on terminal height.
+ */
+export declare function useDynamicLimit(options?: UseDynamicLimitOptions): number;
+export {};

package/dist/hooks/useDynamicLimit.js

@@ -0,0 +1,9 @@
+import { useStdout } from 'ink';
+/**
+ * Calculate the maximum number of list items to display based on terminal height.
+ */
+export function useDynamicLimit(options = {}) {
+    const { fixedRows = 6, isSearchMode = false, hasError = false } = options;
+    const { stdout } = useStdout();
+    return Math.max(5, stdout.rows - fixedRows - (isSearchMode ? 1 : 0) - (hasError ? 3 : 0));
+}

package/dist/services/sessionManager.autoApproval.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { EventEmitter } from 'events';
 import { spawn } from './bunTerminal.js';
-import { STATE_CHECK_INTERVAL_MS, STATE_PERSISTENCE_DURATION_MS, } from '../constants/statePersistence.js';
+import { STATE_PERSISTENCE_DURATION_MS, STATE_MINIMUM_DURATION_MS, } from '../constants/statePersistence.js';
 import { Effect, Either } from 'effect';
 const detectStateMock = vi.fn();
 // Create a deferred promise pattern for controllable mock
@@ -107,24 +107,8 @@ describe('SessionManager - Auto Approval Recovery', () => {
             mockPtyInstances.set(path, mockPty);
             return mockPty;
         });
-        // Detection sequence: first prompt (no auto-approval), back to busy, second prompt (should auto-approve)
-        const detectionStates = [
-            'waiting_input',
-            'waiting_input',
-            'waiting_input',
-            'busy',
-            'busy',
-            'busy',
-            'waiting_input',
-            'waiting_input',
-            'waiting_input',
-        ];
-        let callIndex = 0;
-        detectStateMock.mockImplementation(() => {
-            const state = detectionStates[Math.min(callIndex, detectionStates.length - 1)];
-            callIndex++;
-            return state;
-        });
+        // Start with waiting_input; tests will change the mock return value between phases
+        detectStateMock.mockReturnValue('waiting_input');
         const sessionManagerModule = await import('./sessionManager.js');
         SessionManager = sessionManagerModule.SessionManager;
         sessionManager = new SessionManager();
@@ -141,16 +125,19 @@ describe('SessionManager - Auto Approval Recovery', () => {
             ...data,
             autoApprovalFailed: true,
         }));
-        // First waiting_input cycle (auto-approval suppressed) (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3);
+        // Phase 1: waiting_input (auto-approval suppressed due to prior failure)
+        detectStateMock.mockReturnValue('waiting_input');
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
         expect(session.stateMutex.getSnapshot().state).toBe('waiting_input');
         expect(session.stateMutex.getSnapshot().autoApprovalFailed).toBe(true);
-        // Transition back to busy should reset the failure flag (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3);
+        // Phase 2: busy - should reset the failure flag
+        detectStateMock.mockReturnValue('busy');
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         expect(session.stateMutex.getSnapshot().autoApprovalFailed).toBe(false);
-        // Next waiting_input should trigger pending_auto_approval (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3 + STATE_PERSISTENCE_DURATION_MS);
+        // Phase 3: waiting_input again - should trigger pending_auto_approval
+        detectStateMock.mockReturnValue('waiting_input');
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
         // State should now be pending_auto_approval (waiting for verification)
         expect(session.stateMutex.getSnapshot().state).toBe('pending_auto_approval');
         expect(verifyNeedsPermissionMock).toHaveBeenCalled();
@@ -192,8 +179,9 @@ describe('SessionManager - Auto Approval Recovery', () => {
         expect(mockPty).toBeDefined();
         const handler = vi.fn();
         sessionManager.on('sessionStateChanged', handler);
-        // Advance to pending_auto_approval state (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3 + STATE_PERSISTENCE_DURATION_MS);
+        // Phase 1: waiting_input → pending_auto_approval
+        detectStateMock.mockReturnValue('waiting_input');
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
         // State should be pending_auto_approval (waiting for verification)
         expect(session.stateMutex.getSnapshot().state).toBe('pending_auto_approval');
         expect(verifyNeedsPermissionMock).toHaveBeenCalled();

package/dist/services/sessionManager.js

@@ -7,7 +7,7 @@ import { configReader } from './config/configReader.js';
 import { setWorktreeLastOpened } from './worktreeService.js';
 import { executeStatusHook } from '../utils/hookExecutor.js';
 import { createStateDetector } from './stateDetector/index.js';
-import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
+import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, STATE_MINIMUM_DURATION_MS, } from '../constants/statePersistence.js';
 import { Effect, Either } from 'effect';
 import { ProcessError, ConfigError } from '../types/errors.js';
 import { autoApprovalVerifier } from './autoApprovalVerifier.js';
@@ -177,6 +177,7 @@ export class SessionManager extends EventEmitter {
             state: newState,
             pendingState: undefined,
             pendingStateStart: undefined,
+            stateConfirmedAt: Date.now(),
             ...additionalUpdates,
         }));
         if (oldState !== newState) {
@@ -393,8 +394,11 @@ export class SessionManager extends EventEmitter {
                 else if (stateData.pendingState !== undefined &&
                     stateData.pendingStateStart !== undefined) {
                     // Check if the pending state has persisted long enough
+                    // and that the current state has been active for the minimum duration
                     const duration = now - stateData.pendingStateStart;
-                    if (duration >= STATE_PERSISTENCE_DURATION_MS) {
+                    const timeInCurrentState = now - stateData.stateConfirmedAt;
+                    if (duration >= STATE_PERSISTENCE_DURATION_MS &&
+                        timeInCurrentState >= STATE_MINIMUM_DURATION_MS) {
                         // Cancel auto-approval verification if state is changing away from pending_auto_approval
                         if (stateData.autoApprovalAbortController &&
                             detectedState !== 'pending_auto_approval') {
@@ -417,10 +421,13 @@ export class SessionManager extends EventEmitter {
             }
             else {
                 // Detected state matches current state, clear any pending state
+                // and update stateConfirmedAt so the minimum duration guard
+                // tracks "last time current state was seen" rather than "first confirmed"
                 void session.stateMutex.update(data => ({
                     ...data,
                     pendingState: undefined,
                     pendingStateStart: undefined,
+                    stateConfirmedAt: now,
                 }));
             }
             // Handle auto-approval if state is pending_auto_approval and no verification is in progress.

package/dist/services/sessionManager.statePersistence.test.js

@@ -3,7 +3,7 @@ import { Either } from 'effect';
 import { SessionManager } from './sessionManager.js';
 import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
-import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
+import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, STATE_MINIMUM_DURATION_MS, } from '../constants/statePersistence.js';
 vi.mock('./bunTerminal.js', () => ({
     spawn: vi.fn(function () {
         return null;
@@ -97,7 +97,7 @@ describe('SessionManager - State Persistence', () => {
         expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
         expect(session.stateMutex.getSnapshot().pendingStateStart).toBeDefined();
     });
-    it('should change state after persistence duration is met', async () => {
+    it('should change state after both persistence and minimum duration are met', async () => {
         const { Effect } = await import('effect');
         const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
@@ -111,8 +111,8 @@ describe('SessionManager - State Persistence', () => {
         await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         expect(stateChangeHandler).not.toHaveBeenCalled();
-        // Advance time to exceed persistence duration
-        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS);
+        // Advance time past both persistence and minimum duration
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS);
         // State should now be changed
         expect(session.stateMutex.getSnapshot().state).toBe('idle');
         expect(session.stateMutex.getSnapshot().pendingState).toBeUndefined();
@@ -201,6 +201,72 @@ describe('SessionManager - State Persistence', () => {
         const destroyedSession = sessionManager.getSession('/test/path');
         expect(destroyedSession).toBeUndefined();
     });
+    it('should not transition state before minimum duration in current state has elapsed', async () => {
+        const { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time enough for persistence duration but less than minimum duration
+        // STATE_PERSISTENCE_DURATION_MS (200ms) < STATE_MINIMUM_DURATION_MS (500ms)
+        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS + STATE_CHECK_INTERVAL_MS * 2);
+        // State should still be busy because minimum duration hasn't elapsed
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        expect(stateChangeHandler).not.toHaveBeenCalled();
+    });
+    it('should transition state after both persistence and minimum duration are met', async () => {
+        const { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time past STATE_MINIMUM_DURATION_MS (which is longer than STATE_PERSISTENCE_DURATION_MS)
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_CHECK_INTERVAL_MS);
+        // State should now be idle since both durations are satisfied
+        expect(session.stateMutex.getSnapshot().state).toBe('idle');
+        expect(stateChangeHandler).toHaveBeenCalledWith(session);
+    });
+    it('should not transition during brief screen redraw even after long time in current state', async () => {
+        const { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        // Keep busy state active for a long time (simulating normal operation)
+        // Each check re-detects "busy" and updates stateConfirmedAt
+        eventEmitter.emit('data', 'ESC to interrupt');
+        await vi.advanceTimersByTimeAsync(2000); // 2 seconds of confirmed busy
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        // Now simulate a brief screen redraw: busy indicators disappear temporarily
+        eventEmitter.emit('data', '\x1b[2J\x1b[H'); // Clear screen
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS); // 100ms
+        // Pending state should be set to idle
+        expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
+        // Advance past persistence duration (200ms) but NOT past minimum duration (500ms)
+        // Since stateConfirmedAt was updated at ~2000ms, and now is ~2200ms,
+        // timeInCurrentState = ~200ms which is < 500ms
+        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS);
+        // State should still be busy because minimum duration since last busy detection hasn't elapsed
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        expect(stateChangeHandler).not.toHaveBeenCalled();
+        // Simulate busy indicators coming back (screen redraw complete)
+        eventEmitter.emit('data', 'ESC to interrupt');
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS);
+        // State should still be busy and pending should be cleared
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        expect(session.stateMutex.getSnapshot().pendingState).toBeUndefined();
+        expect(stateChangeHandler).not.toHaveBeenCalled();
+    });
     it('should handle multiple sessions with independent state persistence', async () => {
         const { Effect } = await import('effect');
         const session1 = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path1'));
@@ -222,8 +288,8 @@ describe('SessionManager - State Persistence', () => {
         expect(session1.stateMutex.getSnapshot().pendingState).toBe('idle');
         expect(session2.stateMutex.getSnapshot().state).toBe('busy');
         expect(session2.stateMutex.getSnapshot().pendingState).toBe('waiting_input');
-        // Advance time to confirm both (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS);
+        // Advance time to confirm both - need to exceed STATE_MINIMUM_DURATION_MS (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS);
         // Both should now be in their new states
         expect(session1.stateMutex.getSnapshot().state).toBe('idle');
         expect(session1.stateMutex.getSnapshot().pendingState).toBeUndefined();

package/dist/services/stateDetector/claude.d.ts

@@ -1,6 +1,17 @@
 import { SessionState, Terminal } from '../../types/index.js';
 import { BaseStateDetector } from './base.js';
 export declare class ClaudeStateDetector extends BaseStateDetector {
+    /**
+     * Extract content above the prompt box.
+     * The prompt box is delimited by ─ border lines:
+     *   content above prompt box
+     *   ─────────────── (top border)
+     *   ❯              (prompt line)
+     *   ─────────────── (bottom border)
+     *
+     * If no prompt box is found, returns all content as fallback.
+     */
+    private getContentAbovePromptBox;
     detectState(terminal: Terminal, currentState: SessionState): SessionState;
     detectBackgroundTask(terminal: Terminal): number;
     detectTeamMembers(terminal: Terminal): number;

package/dist/services/stateDetector/claude.js

@@ -1,30 +1,70 @@
 import { BaseStateDetector } from './base.js';
+// Spinner characters used by Claude Code during active processing
+const SPINNER_CHARS = '✱✲✳✴✵✶✷✸✹✺✻✼✽✾✿❀❁❂❃❇❈❉❊❋✢✣✤✥✦✧✨⊛⊕⊙◉◎◍⁂⁕※⍟☼★☆';
+// Matches spinner activity labels like "✽ Tempering…" or "✳ Simplifying recompute_tangents…"
+const SPINNER_ACTIVITY_PATTERN = new RegExp(`^[${SPINNER_CHARS}] \\S+ing.*\u2026`, 'm');
 export class ClaudeStateDetector extends BaseStateDetector {
+    /**
+     * Extract content above the prompt box.
+     * The prompt box is delimited by ─ border lines:
+     *   content above prompt box
+     *   ─────────────── (top border)
+     *   ❯              (prompt line)
+     *   ─────────────── (bottom border)
+     *
+     * If no prompt box is found, returns all content as fallback.
+     */
+    getContentAbovePromptBox(terminal, maxLines) {
+        const lines = this.getTerminalLines(terminal, maxLines);
+        let borderCount = 0;
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const trimmed = lines[i].trim();
+            if (trimmed.length > 0 && /^─+$/.test(trimmed)) {
+                borderCount++;
+                if (borderCount === 2) {
+                    return lines.slice(0, i).join('\n');
+                }
+            }
+        }
+        // No prompt box found, return all content
+        return lines.join('\n');
+    }
     detectState(terminal, currentState) {
         // Check for search prompt (⌕ Search…) within 200 lines - always idle
         const extendedContent = this.getTerminalContent(terminal, 200);
         if (extendedContent.includes('⌕ Search…')) {
             return 'idle';
         }
-        // Existing logic with 30 lines
-        const content = this.getTerminalContent(terminal, 30);
-        const lowerContent = content.toLowerCase();
+        // Full content (including prompt box) for waiting_input detection
+        const fullContent = this.getTerminalContent(terminal, 30);
+        const fullLowerContent = fullContent.toLowerCase();
         // Check for ctrl+r toggle prompt - maintain current state
-        if (lowerContent.includes('ctrl+r to toggle')) {
+        if (fullLowerContent.includes('ctrl+r to toggle')) {
             return currentState;
         }
         // Check for "Do you want" or "Would you like" pattern with options
         // Handles both simple ("Do you want...\nYes") and complex (numbered options) formats
-        if (/(?:do you want|would you like).+\n+[\s\S]*?(?:yes|❯)/.test(lowerContent)) {
+        if (/(?:do you want|would you like).+\n+[\s\S]*?(?:yes|❯)/.test(fullLowerContent)) {
+            return 'waiting_input';
+        }
+        // Check for selection prompt with ❯ cursor indicator and numbered options
+        if (/❯\s+\d+\./.test(fullContent)) {
             return 'waiting_input';
         }
         // Check for "esc to cancel" - indicates waiting for user input
-        if (lowerContent.includes('esc to cancel')) {
+        if (fullLowerContent.includes('esc to cancel')) {
             return 'waiting_input';
         }
+        // Content above the prompt box only for busy detection
+        const abovePromptBox = this.getContentAbovePromptBox(terminal, 30);
+        const aboveLowerContent = abovePromptBox.toLowerCase();
         // Check for busy state
-        if (lowerContent.includes('esc to interrupt') ||
-            lowerContent.includes('ctrl+c to interrupt')) {
+        if (aboveLowerContent.includes('esc to interrupt') ||
+            aboveLowerContent.includes('ctrl+c to interrupt')) {
+            return 'busy';
+        }
+        // Check for spinner activity label (e.g., "✽ Tempering…", "✳ Simplifying…")
+        if (SPINNER_ACTIVITY_PATTERN.test(abovePromptBox)) {
             return 'busy';
         }
         // Otherwise idle

package/dist/services/stateDetector/claude.test.js

@@ -8,19 +8,22 @@ describe('ClaudeStateDetector', () => {
         detector = new ClaudeStateDetector();
     });
     describe('detectState', () => {
-        it('should detect busy when "ESC to interrupt" is present', () => {
+        it('should detect busy when "ESC to interrupt" is above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Processing...',
                 'Press ESC to interrupt',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('busy');
         });
-        it('should detect busy when "esc to interrupt" is present (case insensitive)', () => {
-            // Arrange
+        it('should detect busy when "esc to interrupt" is present (no prompt box fallback)', () => {
+            // Arrange - no prompt box borders, falls back to all content
             terminal = createMockTerminal([
                 'Running command...',
                 'press esc to interrupt the process',
@@ -30,11 +33,14 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('busy');
         });
-        it('should detect busy when "ctrl+c to interrupt" is present (web search)', () => {
+        it('should detect busy when "ctrl+c to interrupt" is above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Googling. (ctrl+c to interrupt',
                 'Searching for relevant information...',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
@@ -93,7 +99,7 @@ describe('ClaudeStateDetector', () => {
                 expect(state).toBe('busy');
             }
         });
-        it('should detect waiting_input when "Do you want" with options prompt is present', () => {
+        it('should detect waiting_input when "Do you want" with options is above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Some previous output',
@@ -101,13 +107,16 @@ describe('ClaudeStateDetector', () => {
                 '❯ 1. Yes',
                 '2. Yes, allow all edits during this session (shift+tab)',
                 '3. No, and tell Claude what to do differently (esc)',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('waiting_input');
         });
-        it('should detect waiting_input when "Do you want" with options prompt is present (case insensitive)', () => {
+        it('should detect waiting_input when "Do you want" is present (no prompt box fallback)', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Some output',
@@ -127,6 +136,9 @@ describe('ClaudeStateDetector', () => {
                 'Do you want to continue?',
                 '❯ 1. Yes',
                 '2. No',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
@@ -190,18 +202,48 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('waiting_input');
         });
-        it('should detect waiting_input when "esc to cancel" is present', () => {
+        it('should detect waiting_input when plan submit prompt with ❯ cursor is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Ready to submit your answers?',
+                '',
+                '❯ 1. Submit answers',
+                '  2. Cancel',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input for generic ❯ numbered selection prompt', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Select an option:',
+                '',
+                '❯ 1. Option A',
+                '  2. Option B',
+                '  3. Option C',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "esc to cancel" is above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Enter your message:',
                 'Press esc to cancel',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('waiting_input');
         });
-        it('should detect waiting_input when "esc to cancel" is present (case insensitive)', () => {
+        it('should detect waiting_input when "esc to cancel" is present (no prompt box fallback)', () => {
             // Arrange
             terminal = createMockTerminal(['Waiting for input', 'ESC TO CANCEL']);
             // Act
@@ -209,12 +251,15 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('waiting_input');
         });
-        it('should prioritize "esc to cancel" over "esc to interrupt" when both present', () => {
+        it('should prioritize "esc to cancel" over "esc to interrupt" when both above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Press esc to interrupt',
                 'Some input prompt',
                 'Press esc to cancel',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
@@ -273,6 +318,87 @@ describe('ClaudeStateDetector', () => {
             // Assert - Should detect waiting_input from viewport
             expect(state).toBe('waiting_input');
         });
+        it('should detect busy when spinner activity label "✽ Tempering…" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                '✽ Tempering…',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy when spinner activity label "✳ Simplifying…" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                '✳ Simplifying recompute_tangents… (2m 18s · ↓ 4.8k tokens)',
+                '  ⎿  ◻ task list items...',
+                '──────────────────────────────',
+                '❯',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy with various spinner characters', () => {
+            const spinnerChars = [
+                '✱',
+                '✲',
+                '✳',
+                '✴',
+                '✵',
+                '✶',
+                '✷',
+                '✸',
+                '✹',
+                '✺',
+                '✻',
+                '✼',
+                '✽',
+                '✾',
+                '✿',
+                '❀',
+                '❁',
+                '❂',
+                '❃',
+                '❇',
+                '❈',
+                '❉',
+                '❊',
+                '❋',
+                '✢',
+                '✣',
+                '✤',
+                '✥',
+                '✦',
+                '✧',
+            ];
+            for (const char of spinnerChars) {
+                terminal = createMockTerminal([`${char} Kneading…`, '❯']);
+                const state = detector.detectState(terminal, 'idle');
+                expect(state).toBe('busy');
+            }
+        });
+        it('should not detect busy for spinner-like line without ing… suffix', () => {
+            // Arrange - no "ing…" at end
+            terminal = createMockTerminal(['✽ Some random text', '❯']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('idle');
+        });
+        it('should detect idle when "⌕ Search…" is present even with spinner activity', () => {
+            // Arrange
+            terminal = createMockTerminal(['⌕ Search…', '✽ Tempering…']);
+            // Act
+            const state = detector.detectState(terminal, 'busy');
+            // Assert - Search prompt takes precedence
+            expect(state).toBe('idle');
+        });
         it('should detect idle when "⌕ Search…" is present', () => {
             // Arrange - Search prompt should always be idle
             terminal = createMockTerminal(['⌕ Search…', 'Some content']);
@@ -297,6 +423,59 @@ describe('ClaudeStateDetector', () => {
             // Assert - Should be idle because search prompt takes precedence
             expect(state).toBe('idle');
         });
+        it('should ignore "esc to interrupt" inside prompt box', () => {
+            // Arrange - "esc to interrupt" is inside the prompt box, not above it
+            terminal = createMockTerminal([
+                'Some idle output',
+                '──────────────────────────────',
+                'esc to interrupt',
+                '──────────────────────────────',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert - should be idle because "esc to interrupt" is inside prompt box
+            expect(state).toBe('idle');
+        });
+        it('should detect "esc to cancel" inside prompt box as waiting_input', () => {
+            // Arrange - waiting_input detection uses full content including prompt box
+            terminal = createMockTerminal([
+                'Some idle output',
+                '──────────────────────────────',
+                'esc to cancel',
+                '──────────────────────────────',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert - waiting_input is not restricted to above prompt box
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect "Do you want" inside prompt box as waiting_input', () => {
+            // Arrange - waiting_input detection uses full content including prompt box
+            terminal = createMockTerminal([
+                'Some idle output',
+                '──────────────────────────────',
+                'Do you want to proceed?',
+                '❯ 1. Yes',
+                '──────────────────────────────',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert - waiting_input is not restricted to above prompt box
+            expect(state).toBe('waiting_input');
+        });
+        it('should ignore spinner activity label inside prompt box', () => {
+            // Arrange - spinner label is inside the prompt box
+            terminal = createMockTerminal([
+                'Some idle output',
+                '──────────────────────────────',
+                '✽ Tempering…',
+                '──────────────────────────────',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert - should be idle because spinner is inside prompt box
+            expect(state).toBe('idle');
+        });
     });
     describe('detectBackgroundTask', () => {
         it('should return count 1 when "1 background task" is in status bar', () => {

package/dist/services/stateDetector/codex.js

@@ -8,6 +8,10 @@ export class CodexStateDetector extends BaseStateDetector {
             /confirm with .+ enter/i.test(content)) {
             return 'waiting_input';
         }
+        // Check for plan/question prompts
+        if (lowerContent.includes('| enter to submit answer')) {
+            return 'waiting_input';
+        }
         // Check for waiting prompts
         if (lowerContent.includes('allow command?') ||
             lowerContent.includes('[y/n]') ||

package/dist/services/stateDetector/codex.test.js

@@ -135,6 +135,34 @@ describe('CodexStateDetector', () => {
         // Assert
         expect(state).toBe('waiting_input');
     });
+    it('should detect waiting_input state for plan question prompt with "| enter to submit answer"', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            '  Question 1/3 (3 unanswered)',
+            '  › 1. 既知CLIのみ (Recommended)',
+            '    2. 全preset対応',
+            '    3. 既知CLI優先+未知は末尾引数',
+            '    4. None of the above',
+            '',
+            '  tab to add notes | enter to submit answer | ←/→ to navigate questions | esc to interrupt',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should prioritize plan question prompt over busy state with esc interrupt', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            '  Question 1/3',
+            '  › 1. Option A',
+            '  tab to add notes | enter to submit answer | esc to interrupt',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
     it('should prioritize "Confirm with ... Enter" over busy state', () => {
         // Arrange
         terminal = createMockTerminal(['Esc to interrupt', 'Confirm with Y Enter']);

package/dist/utils/filterByQuery.d.ts

@@ -0,0 +1,5 @@
+import { Worktree } from '../types/index.js';
+/**
+ * Filter worktrees by matching search query against branch name and path.
+ */
+export declare function filterWorktreesByQuery(worktrees: Worktree[], query: string): Worktree[];

package/dist/utils/filterByQuery.js

@@ -0,0 +1,13 @@
+/**
+ * Filter worktrees by matching search query against branch name and path.
+ */
+export function filterWorktreesByQuery(worktrees, query) {
+    if (!query)
+        return worktrees;
+    const searchLower = query.toLowerCase();
+    return worktrees.filter(worktree => {
+        const branchName = worktree.branch || '';
+        return (branchName.toLowerCase().includes(searchLower) ||
+            worktree.path.toLowerCase().includes(searchLower));
+    });
+}

package/dist/utils/mutex.d.ts

@@ -44,6 +44,7 @@ export interface SessionStateData {
     state: import('../types/index.js').SessionState;
     pendingState: import('../types/index.js').SessionState | undefined;
     pendingStateStart: number | undefined;
+    stateConfirmedAt: number;
     autoApprovalFailed: boolean;
     autoApprovalReason: string | undefined;
     autoApprovalAbortController: AbortController | undefined;

package/dist/utils/mutex.js

@@ -82,6 +82,7 @@ export function createInitialSessionStateData() {
         state: 'busy',
         pendingState: undefined,
         pendingStateStart: undefined,
+        stateConfirmedAt: Date.now(),
         autoApprovalFailed: false,
         autoApprovalReason: undefined,
         autoApprovalAbortController: undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.11.3",
+	"version": "3.12.1",
 	"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": "3.11.3",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.11.3",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.11.3",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.11.3",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.11.3"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.12.1",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.12.1",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.12.1",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.12.1",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.12.1"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",