ccmanager 4.1.17 → 4.1.19

package/dist/components/App.js

@@ -572,6 +572,16 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         setActiveSession(session);
         navigateWithClear('session');
     };
+    const handleSessionActionFromDashboard = (session, project) => {
+        const projectSessionManager = globalSessionOrchestrator.getManagerForProject(project.path);
+        setSessionManager(projectSessionManager);
+        setWorktreeService(new WorktreeService(project.path));
+        setSessionActionsTarget({
+            session,
+            worktreePath: session.worktreePath,
+        });
+        navigateWithClear('session-actions');
+    };
     const handleBackToProjectList = () => {
         // Sessions persist in their project-specific managers
         setSelectedProject(null);
@@ -587,7 +597,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         if (!projectsDir) {
             return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", MULTI_PROJECT_ERRORS.NO_PROJECTS_DIR] }) }));
         }
-        return (_jsx(Dashboard, { projectsDir: projectsDir, onSelectSession: handleSelectSessionFromDashboard, onSelectProject: handleSelectProject, error: error, onDismissError: () => setError(null), version: version }));
+        return (_jsx(Dashboard, { projectsDir: projectsDir, onSelectSession: handleSelectSessionFromDashboard, onSelectProject: handleSelectProject, onSessionAction: handleSessionActionFromDashboard, error: error, onDismissError: () => setError(null), version: version }));
     }
     if (view === 'menu') {
         return (_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: handleMenuAction, onSelectRecentProject: handleSelectProject, error: error, onDismissError: () => setError(null), projectName: selectedProject?.name, multiProject: multiProject, version: version }, menuKey));

package/dist/components/Dashboard.d.ts

@@ -4,6 +4,7 @@ interface DashboardProps {
     projectsDir: string;
     onSelectSession: (session: ISession, project: GitProject) => void;
     onSelectProject: (project: GitProject) => void;
+    onSessionAction?: (session: ISession, project: GitProject) => void;
     error: string | null;
     onDismissError: () => void;
     version: string;

package/dist/components/Dashboard.js

@@ -12,7 +12,7 @@ import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, getStatusDisplay, } from '../c
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
 import { useGitStatus } from '../hooks/useGitStatus.js';
-import { truncateString, calculateColumnPositions, assembleSessionLabel, formatRelativeDate, } from '../utils/worktreeUtils.js';
+import { truncateString, calculateColumnPositions, assembleSessionLabel, formatRelativeDate, displaySuffix, } from '../utils/worktreeUtils.js';
 import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from '../utils/gitStatus.js';
 import SearchableList from './SearchableList.js';
 const MAX_BRANCH_NAME_LENGTH = 70;
@@ -63,7 +63,7 @@ function resolveProjectDisplayNames(projects) {
     }
     return displayNames;
 }
-const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDismissError, version, }) => {
+const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAction, error, onDismissError, version, }) => {
     const [projects, setProjects] = useState([]);
     const [recentProjects, setRecentProjects] = useState([]);
     const [loading, setLoading] = useState(true);
@@ -73,6 +73,8 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
     const [sessionEntries, setSessionEntries] = useState([]);
     const [baseSessionWorktrees, setBaseSessionWorktrees] = useState([]);
     const [sessionRefreshKey, setSessionRefreshKey] = useState(0);
+    const [highlightedSession, setHighlightedSession] = useState(null);
+    const [highlightedProject, setHighlightedProject] = useState(null);
     const displayError = error || loadError;
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
         isDisabled: !!displayError,
@@ -220,7 +222,10 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
                     : wt.path.split('/').pop() || 'detached';
                 const branchName = truncateString(fullBranchName, MAX_BRANCH_NAME_LENGTH);
                 const isMain = wt.isMainWorktree ? ' (main)' : '';
-                const baseLabel = `${entry.projectName} :: ${branchName}${isMain}${status}`;
+                const worktreeSessionCount = sessionEntries.filter(e => e.worktree.path === entry.worktree.path &&
+                    e.projectPath === entry.projectPath).length;
+                const sessionSuffix = displaySuffix(entry.session, worktreeSessionCount > 1);
+                const baseLabel = `${entry.projectName} :: ${branchName}${isMain}${sessionSuffix}${status}`;
                 let fileChanges = '';
                 let aheadBehind = '';
                 let parentBranch = '';
@@ -407,6 +412,11 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
             return;
         }
         switch (keyPressed) {
+            case ' ':
+                if (highlightedSession && highlightedProject && onSessionAction) {
+                    onSessionAction(highlightedSession, highlightedProject);
+                }
+                break;
             case 'r':
                 refreshAll();
                 break;
@@ -447,10 +457,20 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
                         if (!item)
                             return;
                         handleSelect(item);
+                    }, onHighlight: raw => {
+                        const item = items.find(i => i.value === raw?.value);
+                        if (item?.type === 'session') {
+                            setHighlightedSession(item.session);
+                            setHighlightedProject(item.project);
+                        }
+                        else {
+                            setHighlightedSession(null);
+                            setHighlightedProject(null);
+                        }
                     }, 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`
-                                : 'Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search R-Refresh Q-Quit' })] })] }));
+                                ? `Filtered: "${searchQuery}" | ↑↓ Navigate Enter Select | /-Search ESC-Clear 0-9 Quick Select Space-Session actions (session rows only) R-Refresh Q-Quit`
+                                : 'Controls: ↑↓ Navigate Enter Select | Hotkeys: 0-9 Quick Select /-Search Space-Session actions (session rows only) R-Refresh Q-Quit' })] })] }));
 };
 export default Dashboard;

package/dist/components/Dashboard.test.js

@@ -1,26 +1,50 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from 'ink-testing-library';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+const capturedHandlers = { inputHandlers: [], onHighlight: null };
+const makeKey = (overrides = {}) => ({
+    upArrow: false,
+    downArrow: false,
+    leftArrow: false,
+    rightArrow: false,
+    pageDown: false,
+    pageUp: false,
+    home: false,
+    end: false,
+    return: false,
+    escape: false,
+    ctrl: false,
+    shift: false,
+    tab: false,
+    backspace: false,
+    delete: false,
+    meta: false,
+    ...overrides,
+});
 // Mock bunTerminal to avoid native module loading issues
 vi.mock('../services/bunTerminal.js', () => ({
     spawn: vi.fn(function () {
         return null;
     }),
 }));
-// Import the actual component code but skip the useInput hook
+// Import the actual component code but capture useInput handlers
 vi.mock('ink', async () => {
     const actual = await vi.importActual('ink');
     return {
         ...actual,
-        useInput: vi.fn(),
+        useInput: vi.fn((handler) => {
+            capturedHandlers.inputHandlers.push(handler);
+        }),
     };
 });
-// Mock SelectInput to render items as simple text
+// Mock SelectInput to render items as simple text and capture onHighlight
 vi.mock('ink-select-input', async () => {
     const React = await vi.importActual('react');
     const { Text, Box } = await vi.importActual('ink');
     return {
-        default: ({ items }) => {
+        default: ({ items, onHighlight, }) => {
+            if (onHighlight)
+                capturedHandlers.onHighlight = onHighlight;
             return React.createElement(Box, { flexDirection: 'column' }, items.map((item, index) => React.createElement(Text, { key: index }, item.label)));
         },
     };
@@ -120,6 +144,8 @@ describe('Dashboard', () => {
     ];
     beforeEach(() => {
         vi.clearAllMocks();
+        capturedHandlers.inputHandlers = [];
+        capturedHandlers.onHighlight = null;
         vi.mocked(projectManager.instance.discoverProjectsEffect).mockReturnValue(Effect.succeed(mockProjects));
         vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([]);
         vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([]);
@@ -308,6 +334,7 @@ describe('Dashboard', () => {
         const { lastFrame } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
         expect(lastFrame()).toContain('Controls:');
         expect(lastFrame()).toContain('0-9 Quick Select');
+        expect(lastFrame()).toContain('Space-Session actions');
         expect(lastFrame()).toContain('R-Refresh');
         expect(lastFrame()).toContain('Q-Quit');
     });
@@ -345,4 +372,261 @@ describe('Dashboard', () => {
         // shared-lib should appear first (index 0) because it's recent
         expect(frame).toContain('0 ❯ shared-lib');
     });
+    it('should show session name suffix in label when session has a name', async () => {
+        const mockSession = {
+            id: 'session-named',
+            worktreePath: '/projects/my-app/worktrees/feature-auth',
+            sessionNumber: 1,
+            sessionName: 'my-feature',
+            lastActivity: new Date(),
+            isActive: true,
+            stateMutex: {
+                getSnapshot: () => ({
+                    state: 'busy',
+                    backgroundTaskCount: 0,
+                    teamMemberCount: 0,
+                }),
+            },
+        };
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([
+            '/projects/my-app',
+        ]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([
+            mockSession,
+        ]);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: () => Effect.succeed([
+                    {
+                        path: '/projects/my-app/worktrees/feature-auth',
+                        branch: 'feature/auth',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+                getGitRootPath: () => '/projects/my-app',
+            };
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('Active Sessions') ?? false;
+        }, { timeout: 3000 });
+        expect(lastFrame()).toContain('my-app :: feature/auth: my-feature');
+    });
+    it('should show session number suffix when multiple unnamed sessions on same worktree', async () => {
+        const mockSessions = [
+            {
+                id: 'session-1',
+                worktreePath: '/projects/my-app/worktrees/feature-auth',
+                sessionNumber: 1,
+                lastActivity: new Date(),
+                isActive: true,
+                stateMutex: {
+                    getSnapshot: () => ({
+                        state: 'busy',
+                        backgroundTaskCount: 0,
+                        teamMemberCount: 0,
+                    }),
+                },
+            },
+            {
+                id: 'session-2',
+                worktreePath: '/projects/my-app/worktrees/feature-auth',
+                sessionNumber: 2,
+                lastActivity: new Date(),
+                isActive: true,
+                stateMutex: {
+                    getSnapshot: () => ({
+                        state: 'idle',
+                        backgroundTaskCount: 0,
+                        teamMemberCount: 0,
+                    }),
+                },
+            },
+        ];
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([
+            '/projects/my-app',
+        ]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue(mockSessions);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: () => Effect.succeed([
+                    {
+                        path: '/projects/my-app/worktrees/feature-auth',
+                        branch: 'feature/auth',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+                getGitRootPath: () => '/projects/my-app',
+            };
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('Active Sessions') ?? false;
+        }, { timeout: 3000 });
+        const frame = lastFrame();
+        expect(frame).toContain('#1');
+        expect(frame).toContain('#2');
+    });
+    it('should show no session suffix for single unnamed session', async () => {
+        const mockSession = {
+            id: 'session-single',
+            worktreePath: '/projects/my-app/worktrees/feature-auth',
+            sessionNumber: 1,
+            lastActivity: new Date(),
+            isActive: true,
+            stateMutex: {
+                getSnapshot: () => ({
+                    state: 'busy',
+                    backgroundTaskCount: 0,
+                    teamMemberCount: 0,
+                }),
+            },
+        };
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([
+            '/projects/my-app',
+        ]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([
+            mockSession,
+        ]);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: () => Effect.succeed([
+                    {
+                        path: '/projects/my-app/worktrees/feature-auth',
+                        branch: 'feature/auth',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+                getGitRootPath: () => '/projects/my-app',
+            };
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('Active Sessions') ?? false;
+        }, { timeout: 3000 });
+        const frame = lastFrame();
+        expect(frame).toContain('my-app :: feature/auth');
+        expect(frame).not.toContain('feature/auth:');
+        expect(frame).not.toContain('feature/auth #');
+    });
+    it('should call onSessionAction when space is pressed on highlighted session', async () => {
+        const mockOnSessionAction = vi.fn();
+        const mockSession = {
+            id: 'session-action',
+            worktreePath: '/projects/my-app/worktrees/feature-auth',
+            sessionNumber: 1,
+            lastActivity: new Date(),
+            isActive: true,
+            stateMutex: {
+                getSnapshot: () => ({
+                    state: 'busy',
+                    backgroundTaskCount: 0,
+                    teamMemberCount: 0,
+                }),
+            },
+        };
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([
+            '/projects/my-app',
+        ]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([
+            mockSession,
+        ]);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: () => Effect.succeed([
+                    {
+                        path: '/projects/my-app/worktrees/feature-auth',
+                        branch: 'feature/auth',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+                getGitRootPath: () => '/projects/my-app',
+            };
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, onSessionAction: mockOnSessionAction, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, onSessionAction: mockOnSessionAction, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('Active Sessions') ?? false;
+        }, { timeout: 3000 });
+        // Enable the useInput handler (Dashboard guards on process.stdin.setRawMode)
+        const origSetRawMode = process.stdin.setRawMode;
+        process.stdin.setRawMode = vi.fn();
+        // Simulate highlighting a session item
+        expect(capturedHandlers.onHighlight).not.toBeNull();
+        capturedHandlers.onHighlight({
+            value: 'session-session-action',
+            label: 'my-app :: feature/auth',
+        });
+        // Force re-render to flush state update — new useInput handler captures updated closure
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, onSessionAction: mockOnSessionAction, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 50));
+        // Use the latest Dashboard handler (last in array — has updated highlightedSession state)
+        const latestHandler = capturedHandlers.inputHandlers[capturedHandlers.inputHandlers.length - 1];
+        expect(latestHandler).toBeDefined();
+        latestHandler(' ', makeKey());
+        expect(mockOnSessionAction).toHaveBeenCalledWith(expect.objectContaining({ id: 'session-action' }), expect.objectContaining({ path: '/projects/my-app' }));
+        process.stdin.setRawMode = origSetRawMode;
+    });
+    it('should not call onSessionAction when space is pressed with no highlighted session', async () => {
+        const mockOnSessionAction = vi.fn();
+        const mockSession = {
+            id: 'session-noop',
+            worktreePath: '/projects/my-app/worktrees/feature-auth',
+            sessionNumber: 1,
+            lastActivity: new Date(),
+            isActive: true,
+            stateMutex: {
+                getSnapshot: () => ({
+                    state: 'busy',
+                    backgroundTaskCount: 0,
+                    teamMemberCount: 0,
+                }),
+            },
+        };
+        vi.mocked(globalSessionOrchestrator.getProjectPaths).mockReturnValue([
+            '/projects/my-app',
+        ]);
+        vi.mocked(globalSessionOrchestrator.getProjectSessions).mockReturnValue([
+            mockSession,
+        ]);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: () => Effect.succeed([
+                    {
+                        path: '/projects/my-app/worktrees/feature-auth',
+                        branch: 'feature/auth',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+                getGitRootPath: () => '/projects/my-app',
+            };
+        });
+        const { lastFrame, rerender } = render(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, onSessionAction: mockOnSessionAction, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await new Promise(resolve => setTimeout(resolve, 200));
+        rerender(_jsx(Dashboard, { projectsDir: "/projects", onSelectSession: mockOnSelectSession, onSelectProject: mockOnSelectProject, onSessionAction: mockOnSessionAction, error: null, onDismissError: mockOnDismissError, version: "3.8.1" }));
+        await vi.waitFor(() => {
+            return lastFrame()?.includes('Active Sessions') ?? false;
+        }, { timeout: 3000 });
+        // Enable the useInput handler (Dashboard guards on process.stdin.setRawMode)
+        const origSetRawMode = process.stdin.setRawMode;
+        process.stdin.setRawMode = vi.fn();
+        // Do NOT call onHighlight — highlightedSession stays null
+        const dashboardHandler = capturedHandlers.inputHandlers.find(handler => handler !== capturedHandlers.inputHandlers[0]);
+        expect(dashboardHandler).toBeDefined();
+        dashboardHandler(' ', makeKey());
+        expect(mockOnSessionAction).not.toHaveBeenCalled();
+        process.stdin.setRawMode = origSetRawMode;
+    });
 });

package/dist/components/Session.js

@@ -45,6 +45,8 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
                 return;
             // Check for return to menu shortcut
             if (shortcutManager.matchesRawInput('returnToMenu', data)) {
+                isExitingRef.current = true;
+                sessionManager.setSessionActive(session.id, false);
                 // Disable any extended input modes that might have been enabled by the PTY
                 if (stdout) {
                     resetTerminalInputModes();
@@ -72,7 +74,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         // restore and the deferred restore that may fire after Session.tsx
         // has already disabled DECAWM for live TUI redraws.
         const handleSessionRestore = (restoredSession, restoreSnapshot) => {
-            if (restoredSession.id === session.id) {
+            if (restoredSession.id === session.id && !isExitingRef.current) {
                 if (restoreSnapshot.length > 0) {
                     stdout.write(`\x1b[?7h${restoreSnapshot}\x1b[?7l`);
                 }
@@ -86,7 +88,9 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         // appends below the (already-clipped) viewport, producing duplicated
         // rows equal to the resize delta.
         const handleSessionResize = (resizedSession, redrawPayload) => {
-            if (resizedSession.id === session.id && redrawPayload.length > 0) {
+            if (resizedSession.id === session.id &&
+                redrawPayload.length > 0 &&
+                !isExitingRef.current) {
                 stdout.write(redrawPayload);
             }
         };

package/dist/components/Session.test.js

@@ -99,4 +99,56 @@ describe('Session', () => {
         expect(testState.stdout?.write).toHaveBeenNthCalledWith(2, '\x1b[?7h\nrestored\x1b[?7l');
         expect(testState.stdout?.write).toHaveBeenNthCalledWith(3, '\x1b[?7l');
     });
+    it('detaches synchronously when returning to menu so late session output cannot repaint', async () => {
+        const listeners = new Map();
+        const session = {
+            id: 'session-1',
+            process: {
+                write: vi.fn(),
+                resize: vi.fn(),
+            },
+            terminal: {
+                resize: vi.fn(),
+            },
+            stateMutex: {
+                getSnapshot: () => ({ state: 'busy' }),
+            },
+        };
+        const onReturnToMenu = vi.fn();
+        const setSessionActive = vi.fn();
+        const sessionManager = {
+            on: vi.fn((event, handler) => {
+                const handlers = listeners.get(event) ?? new Set();
+                handlers.add(handler);
+                listeners.set(event, handlers);
+                return sessionManager;
+            }),
+            off: vi.fn((event, handler) => {
+                listeners.get(event)?.delete(handler);
+                return sessionManager;
+            }),
+            setSessionActive,
+            cancelAutoApproval: vi.fn(),
+            performResize: vi.fn(),
+        };
+        const { unmount } = render(_jsx(Session, { session: session, sessionManager: sessionManager, onReturnToMenu: onReturnToMenu }));
+        await new Promise(resolve => setTimeout(resolve, 0));
+        testState.stdout?.write.mockClear();
+        process.stdin.emit('data', '\u0005');
+        for (const handler of listeners.get('sessionData') ?? []) {
+            handler(session, 'late-data');
+        }
+        for (const handler of listeners.get('sessionRestore') ?? []) {
+            handler(session, 'late-restore');
+        }
+        for (const handler of listeners.get('sessionResize') ?? []) {
+            handler(session, 'late-resize');
+        }
+        expect(setSessionActive).toHaveBeenCalledWith(session.id, false);
+        expect(onReturnToMenu).toHaveBeenCalledTimes(1);
+        expect(testState.stdout?.write).not.toHaveBeenCalledWith('late-data');
+        expect(testState.stdout?.write).not.toHaveBeenCalledWith('\x1b[?7hlate-restore\x1b[?7l');
+        expect(testState.stdout?.write).not.toHaveBeenCalledWith('late-resize');
+        unmount();
+    });
 });

package/dist/services/sessionManager.d.ts

@@ -22,6 +22,8 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private resizeSuppressTimers;
     private restoreDeferTimers;
     private restoreDeferDeadlines;
+    private cursorRedrawSessions;
+    private cursorRedrawTimers;
     private spawn;
     private resolvePreset;
     detectTerminalState(session: Session): SessionState;
@@ -42,6 +44,9 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     constructor();
     private createTerminal;
     private shouldResetRestoreScrollback;
+    private hasCursorAddressedRedraw;
+    private markCursorRedrawActive;
+    private handleScrollbackGrowthDuringRedraw;
     private getRestoreSnapshot;
     private getViewportRedrawSnapshot;
     /**
@@ -89,6 +94,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private armRestoreDeferTimer;
     private fireRestoreDefer;
     private cancelRestoreDefer;
+    private clearCursorRedrawTracking;
     cancelAutoApproval(sessionId: string, reason?: string): void;
     toggleAutoApprovalForWorktree(worktreePath: string): boolean;
     isAutoApprovalDisabledForWorktree(worktreePath: string): boolean;

package/dist/services/sessionManager.js

@@ -20,7 +20,7 @@ import { preparePresetLaunch } from '../utils/presetPrompt.js';
 const { Terminal } = pkg;
 const TERMINAL_CONTENT_MAX_LINES = 300;
 const TERMINAL_SCROLLBACK_LINES = 5000;
-const TERMINAL_RESTORE_SCROLLBACK_LINES = 200;
+const TERMINAL_RESTORE_SCROLLBACK_LINES = TERMINAL_SCROLLBACK_LINES;
 // How long to suppress PTY → stdout forwarding after a viewport resize so the
 // child process's SIGWINCH-triggered re-emission of static content does not
 // duplicate already-displayed rows in the user's terminal.
@@ -33,6 +33,11 @@ const RESIZE_SUPPRESS_MS = 250;
 // streaming session still restores within a small bounded delay.
 const RESTORE_DEFER_QUIET_MS = 80;
 const RESTORE_DEFER_MAX_MS = 250;
+// Cursor-addressed redraws (progress bars, spinners, TUIs) can leave transient
+// rows in scrollback if the viewport scrolls before those rows are overwritten.
+// Keep a short generic redraw window so restore can skip that ghost-bearing
+// range without depending on any specific CLI output text.
+const REDRAW_SCROLLBACK_QUIET_MS = 500;
 export class SessionManager extends EventEmitter {
     sessions;
     waitingWithBottomBorder = new Map();
@@ -44,6 +49,8 @@ export class SessionManager extends EventEmitter {
     resizeSuppressTimers = new Map();
     restoreDeferTimers = new Map();
     restoreDeferDeadlines = new Map();
+    cursorRedrawSessions = new Set();
+    cursorRedrawTimers = new Map();
     async spawn(command, args, worktreePath, options = {}) {
         const spawnOptions = {
             name: 'xterm-256color',
@@ -231,6 +238,35 @@ export class SessionManager extends EventEmitter {
             data.includes('\x1b[3J') ||
             data.includes('\x1bc'));
     }
+    hasCursorAddressedRedraw(data) {
+        return (
+        // CSI cursor movement/positioning, erase, and scroll controls.
+        /\x1b\[[0-?]*[ -/]*[ABCDEFGHJKSTX`abcdefg]/.test(data) ||
+            // DEC save/restore cursor.
+            /\x1b[78]/.test(data) ||
+            // Synchronized output mode usually brackets full-frame redraws.
+            /\x1b\[\?2026[hl]/.test(data));
+    }
+    markCursorRedrawActive(session) {
+        this.cursorRedrawSessions.add(session.id);
+        const existing = this.cursorRedrawTimers.get(session.id);
+        if (existing !== undefined) {
+            clearTimeout(existing);
+        }
+        const timer = setTimeout(() => {
+            this.cursorRedrawTimers.delete(session.id);
+            this.cursorRedrawSessions.delete(session.id);
+        }, REDRAW_SCROLLBACK_QUIET_MS);
+        this.cursorRedrawTimers.set(session.id, timer);
+    }
+    handleScrollbackGrowthDuringRedraw(session, beforeBaseY) {
+        const afterBaseY = session.terminal.buffer.normal.baseY;
+        if (afterBaseY <= beforeBaseY ||
+            !this.cursorRedrawSessions.has(session.id)) {
+            return;
+        }
+        session.restoreScrollbackBaseLine = Math.max(session.restoreScrollbackBaseLine, afterBaseY);
+    }
     getRestoreSnapshot(session) {
         const activeBuffer = session.terminal.buffer.active;
         if (activeBuffer.type !== 'normal') {
@@ -245,19 +281,6 @@ export class SessionManager extends EventEmitter {
         }
         const cursorRow = normalBuffer.cursorY + 1;
         const cursorCol = normalBuffer.cursorX + 1;
-        // When the live viewport shows a transient footer (spinner activity,
-        // token stats, persistent shift+tab footer, etc.), the renderer keeps
-        // redrawing it in place and earlier copies have likely been pushed into
-        // scrollback by chat output scrolling beneath it. Replaying that
-        // scrollback would paint duplicated footer rows, so emit only the
-        // viewport in this case.
-        if (session.stateDetector.hasTransientRenderFooter(session.terminal)) {
-            const viewportSnapshot = session.serializer.serialize({
-                scrollback: 0,
-                excludeAltBuffer: true,
-            });
-            return `${viewportSnapshot}\x1b[${cursorRow};${cursorCol}H`;
-        }
         const scrollbackStart = Math.max(0, normalBuffer.baseY - TERMINAL_RESTORE_SCROLLBACK_LINES);
         const rangeStart = Math.max(session.restoreScrollbackBaseLine, scrollbackStart);
         const rangeEnd = bufferLength - 1;
@@ -434,8 +457,13 @@ export class SessionManager extends EventEmitter {
     setupDataHandler(session) {
         // This handler always runs for all data
         session.process.onData((data) => {
+            const beforeBaseY = session.terminal.buffer.normal.baseY;
+            if (this.hasCursorAddressedRedraw(data)) {
+                this.markCursorRedrawActive(session);
+            }
             // Write data to virtual terminal
             session.terminal.write(data);
+            this.handleScrollbackGrowthDuringRedraw(session, beforeBaseY);
             if (this.shouldResetRestoreScrollback(data)) {
                 session.restoreScrollbackBaseLine =
                     session.terminal.buffer.normal.baseY;
@@ -678,6 +706,14 @@ export class SessionManager extends EventEmitter {
         }
         this.restoreDeferDeadlines.delete(sessionId);
     }
+    clearCursorRedrawTracking(sessionId) {
+        this.cursorRedrawSessions.delete(sessionId);
+        const timer = this.cursorRedrawTimers.get(sessionId);
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            this.cursorRedrawTimers.delete(sessionId);
+        }
+    }
     cancelAutoApproval(sessionId, reason = 'User input received') {
         const session = this.sessions.get(sessionId);
         if (!session) {
@@ -755,6 +791,7 @@ export class SessionManager extends EventEmitter {
                 clearTimeout(resizeTimer);
                 this.resizeSuppressTimers.delete(sessionId);
             }
+            this.clearCursorRedrawTracking(sessionId);
             this.cancelRestoreDefer(sessionId);
             this.emit('sessionDestroyed', session);
         }
@@ -815,6 +852,7 @@ export class SessionManager extends EventEmitter {
                     clearTimeout(resizeTimer);
                     this.resizeSuppressTimers.delete(sessionId);
                 }
+                this.clearCursorRedrawTracking(sessionId);
                 this.cancelRestoreDefer(sessionId);
                 this.emit('sessionDestroyed', session);
             },

package/dist/services/sessionManager.test.js

@@ -774,7 +774,7 @@ describe('SessionManager', () => {
         });
     });
     describe('session restore snapshots', () => {
-        it('should emit a bounded normal-buffer restore snapshot and restore the cursor position', async () => {
+        it('should emit a normal-buffer restore snapshot from the restore baseline and restore the cursor position', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
@@ -803,6 +803,32 @@ describe('SessionManager', () => {
             });
             expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mrestored\u001b[0m\u001b[8;12H');
         });
+        it('should restore all retained normal-buffer scrollback when no baseline excludes it', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            const normalBuffer = session.terminal.buffer.normal;
+            normalBuffer.baseY = 260;
+            normalBuffer.length = 300;
+            normalBuffer.cursorY = 7;
+            normalBuffer.cursorX = 11;
+            session.restoreScrollbackBaseLine = 0;
+            const serializeMock = vi
+                .spyOn(session.serializer, 'serialize')
+                .mockReturnValue('\u001b[31mrestored\u001b[0m');
+            sessionManager.setSessionActive(session.id, true);
+            expect(serializeMock).toHaveBeenCalledWith({
+                range: {
+                    start: 0,
+                    end: 299,
+                },
+                excludeAltBuffer: true,
+            });
+        });
         it('should keep viewport-only restore behavior for alternate screen sessions', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -847,6 +873,69 @@ describe('SessionManager', () => {
             mockPty.emit('data', '\x1b[2J\x1b[Hfresh');
             expect(session.restoreScrollbackBaseLine).toBe(17);
         });
+        it('should keep full scrollback for normal output that scrolls', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            const normalBuffer = session.terminal.buffer.normal;
+            normalBuffer.baseY = 10;
+            vi.mocked(session.terminal.write).mockImplementation(() => {
+                normalBuffer.baseY = 12;
+            });
+            mockPty.emit('data', 'ordinary output\n');
+            expect(session.restoreScrollbackBaseLine).toBe(0);
+        });
+        it('should skip scrollback that grows during cursor-addressed redraws', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            const normalBuffer = session.terminal.buffer.normal;
+            normalBuffer.baseY = 10;
+            vi.mocked(session.terminal.write).mockImplementation(() => {
+                normalBuffer.baseY = 12;
+            });
+            mockPty.emit('data', '\x1b[Hredrawn status\n');
+            expect(session.restoreScrollbackBaseLine).toBe(12);
+        });
+        it('should keep cursor-addressed redraw tracking active for a short quiet window', async () => {
+            vi.useFakeTimers();
+            try {
+                vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                    id: '1',
+                    name: 'Main',
+                    command: 'claude',
+                });
+                vi.mocked(spawn).mockReturnValue(mockPty);
+                const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+                const normalBuffer = session.terminal.buffer.normal;
+                normalBuffer.baseY = 10;
+                vi.mocked(session.terminal.write).mockImplementation(() => {
+                    if (normalBuffer.baseY === 10) {
+                        return;
+                    }
+                    normalBuffer.baseY++;
+                });
+                mockPty.emit('data', '\x1b[Hredraw frame');
+                normalBuffer.baseY = 11;
+                mockPty.emit('data', 'plain continuation that scrolls');
+                expect(session.restoreScrollbackBaseLine).toBe(12);
+                vi.advanceTimersByTime(501);
+                normalBuffer.baseY = 20;
+                mockPty.emit('data', 'ordinary output after quiet window');
+                expect(session.restoreScrollbackBaseLine).toBe(12);
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
         it('should flush live session data after the restore snapshot completes', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -872,7 +961,7 @@ describe('SessionManager', () => {
             sessionManager.setSessionActive(session.id, true);
             expect(eventOrder).toEqual(['restore', 'data']);
         });
-        it('should defer the viewport-only restore until PTY output is quiet when a transient footer is visible', async () => {
+        it('should defer the scrollback restore until PTY output is quiet when a transient footer is visible', async () => {
             vi.useFakeTimers();
             try {
                 vi.mocked(configReader.getDefaultPreset).mockReturnValue({
@@ -899,10 +988,13 @@ describe('SessionManager', () => {
                 expect(serializeMock).not.toHaveBeenCalled();
                 vi.advanceTimersByTime(80);
                 expect(serializeMock).toHaveBeenCalledWith({
-                    scrollback: 0,
+                    range: {
+                        start: 120,
+                        end: 299,
+                    },
                     excludeAltBuffer: true,
                 });
-                expect(serializeMock).not.toHaveBeenCalledWith(expect.objectContaining({ range: expect.anything() }));
+                expect(serializeMock).not.toHaveBeenCalledWith(expect.objectContaining({ scrollback: 0 }));
                 expect(restoreHandler).toHaveBeenCalledWith(session, 'viewport');
             }
             finally {

package/dist/utils/worktreeUtils.d.ts

@@ -29,6 +29,7 @@ export declare function extractBranchParts(branchName: string): {
     prefix?: string;
     name: string;
 };
+export declare function displaySuffix(session: Session, multipleForWorktree: boolean): string;
 /**
  * Prepares session items for display.
  * Supports multiple sessions per worktree.

package/dist/utils/worktreeUtils.js

@@ -122,7 +122,7 @@ function indexSessionsByWorktree(sessions) {
     }
     return { byWorktreePath, maxAccessAt };
 }
-function displaySuffix(session, multipleForWorktree) {
+export function displaySuffix(session, multipleForWorktree) {
     if (multipleForWorktree) {
         return session.sessionName
             ? `: ${session.sessionName}`

package/package.json

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