ccmanager 4.1.24 → 4.2.1

package/dist/components/App.js

@@ -32,6 +32,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     const [error, setError] = useState(null);
     const [worktreeHookError, setWorktreeHookError] = useState(null);
     const [menuKey, setMenuKey] = useState(0); // Force menu refresh
+    const [menuSnapshots, setMenuSnapshots] = useState({});
     const [selectedWorktree, setSelectedWorktree] = useState(null); // Store selected worktree for preset selection
     const [renameTarget, setRenameTarget] = useState(null);
     const [sessionActionsTarget, setSessionActionsTarget] = useState(null);
@@ -45,6 +46,25 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     // State for streaming devcontainer up logs
     const [devcontainerLogs, setDevcontainerLogs] = useState([]);
     const [canReturnFromHookError, setCanReturnFromHookError] = useState(false);
+    const menuSnapshotKey = selectedProject?.path ?? process.cwd();
+    const handleMenuSnapshotChange = useCallback((snapshot) => {
+        setMenuSnapshots(previous => ({
+            ...previous,
+            [menuSnapshotKey]: snapshot,
+        }));
+    }, [menuSnapshotKey]);
+    const updateMenuSnapshot = useCallback((update) => {
+        setMenuSnapshots(previous => {
+            const current = previous[menuSnapshotKey];
+            if (!current) {
+                return previous;
+            }
+            return {
+                ...previous,
+                [menuSnapshotKey]: update(current),
+            };
+        });
+    }, [menuSnapshotKey]);
     useEffect(() => {
         if (view !== 'worktree-hook-error') {
             setCanReturnFromHookError(false);
@@ -219,6 +239,18 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     // Helper function to handle worktree creation results
     const handleWorktreeCreationResult = (result, creationData) => {
         if (result.success) {
+            updateMenuSnapshot(snapshot => ({
+                ...snapshot,
+                worktrees: [
+                    ...snapshot.worktrees.filter(worktree => worktree.path !== creationData.path),
+                    {
+                        path: creationData.path,
+                        branch: creationData.branch,
+                        isMainWorktree: false,
+                        hasSession: false,
+                    },
+                ],
+            }));
             if (result.warning) {
                 setError(null);
                 setWorktreeHookError(result.warning);
@@ -516,6 +548,11 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             }
         }
         if (!hasError) {
+            const deletedPaths = new Set(worktreePaths);
+            updateMenuSnapshot(snapshot => ({
+                ...snapshot,
+                worktrees: snapshot.worktrees.filter(worktree => !deletedPaths.has(worktree.path)),
+            }));
             // Success - return to menu
             handleReturnToMenu();
         }
@@ -581,7 +618,7 @@ const App = ({ devcontainerConfig, multiProject, 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));
+        return (_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, initialSnapshot: menuSnapshots[menuSnapshotKey], onSnapshotChange: handleMenuSnapshotChange, onMenuAction: handleMenuAction, onSelectRecentProject: handleSelectProject, error: error, onDismissError: () => setError(null), projectName: selectedProject?.name, multiProject: multiProject, version: version }, menuKey));
     }
     if (view === 'session' && activeSession) {
         return (_jsx(Box, { flexDirection: "column", children: _jsx(Session, { session: activeSession, sessionManager: sessionManager, onReturnToMenu: handleReturnToMenu }, activeSession.id) }));

package/dist/components/App.test.js

@@ -169,6 +169,46 @@ describe('App component view state', () => {
     });
 });
 describe('App component loading state machine', () => {
+    it('updates the cached worktree snapshot after creating and deleting worktrees', async () => {
+        const { unmount } = render(_jsx(App, { version: "test" }));
+        await waitForCondition(() => Boolean(menuProps));
+        menuProps.onSnapshotChange?.({
+            worktrees: [
+                {
+                    path: '/tmp/existing',
+                    branch: 'existing',
+                    isMainWorktree: true,
+                    hasSession: false,
+                },
+            ],
+            defaultBranch: 'main',
+        });
+        await flush();
+        await Promise.resolve(menuProps.onMenuAction({ type: 'newWorktree' }));
+        await waitForCondition(() => Boolean(newWorktreeProps));
+        await Promise.resolve(newWorktreeProps.onComplete({
+            creationMode: 'manual',
+            path: '/tmp/created',
+            branch: 'created',
+            baseBranch: 'main',
+            copySessionData: false,
+            copyClaudeDirectory: false,
+        }));
+        await waitForCondition(() => Boolean(menuProps?.initialSnapshot?.worktrees.some(worktree => worktree.path === '/tmp/created')));
+        await Promise.resolve(menuProps.onMenuAction({ type: 'deleteWorktree' }));
+        await waitForCondition(() => Boolean(deleteWorktreeProps));
+        await Promise.resolve(deleteWorktreeProps.onComplete(['/tmp/created'], true));
+        await waitForCondition(() => !menuProps?.initialSnapshot?.worktrees.some(worktree => worktree.path === '/tmp/created'));
+        expect(menuProps?.initialSnapshot?.worktrees).toEqual([
+            {
+                path: '/tmp/existing',
+                branch: 'existing',
+                isMainWorktree: true,
+                hasSession: false,
+            },
+        ]);
+        unmount();
+    });
     it('displays copying message while creating a worktree with session data', async () => {
         let resolveWorktree;
         createWorktreeEffectMock.mockImplementation(() => Effect.tryPromise({

package/dist/components/Menu.d.ts

@@ -1,10 +1,12 @@
 import React from 'react';
-import { GitProject, MenuAction } from '../types/index.js';
+import { Worktree, GitProject, MenuAction } from '../types/index.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { SessionManager } from '../services/sessionManager.js';
 interface MenuProps {
     sessionManager: SessionManager;
     worktreeService: WorktreeService;
+    initialSnapshot?: MenuSnapshot;
+    onSnapshotChange?: (snapshot: MenuSnapshot) => void;
     onMenuAction: (action: MenuAction) => void;
     onSelectRecentProject?: (project: GitProject) => void;
     error?: string | null;
@@ -13,5 +15,10 @@ interface MenuProps {
     multiProject?: boolean;
     version: string;
 }
+export interface MenuSnapshot {
+    worktrees: Worktree[];
+    defaultBranch: string | null;
+    loadError?: string | null;
+}
 declare const Menu: React.FC<MenuProps>;
 export default Menu;

package/dist/components/Menu.js

@@ -1,5 +1,5 @@
 import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import { Effect } from 'effect';
@@ -29,10 +29,15 @@ const createSeparatorWithText = (text, totalWidth = 35) => {
 const formatGitError = (error) => {
     return `Git command failed: ${error.command} (exit ${error.exitCode})\n${error.stderr}`;
 };
-const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentProject, error, onDismissError, projectName, multiProject = false, version, }) => {
-    const [baseWorktrees, setBaseWorktrees] = useState([]);
-    const [defaultBranch, setDefaultBranch] = useState(null);
-    const [loadError, setLoadError] = useState(null);
+const Menu = ({ sessionManager, worktreeService, initialSnapshot, onSnapshotChange, onMenuAction, onSelectRecentProject, error, onDismissError, projectName, multiProject = false, version, }) => {
+    const [baseWorktrees, setBaseWorktrees] = useState(() => initialSnapshot?.worktrees ?? []);
+    const [defaultBranch, setDefaultBranch] = useState(() => initialSnapshot?.defaultBranch ?? null);
+    const [loadError, setLoadError] = useState(() => initialSnapshot?.loadError ?? null);
+    const snapshotRef = useRef({
+        worktrees: initialSnapshot?.worktrees ?? [],
+        defaultBranch: initialSnapshot?.defaultBranch ?? null,
+        loadError: initialSnapshot?.loadError ?? null,
+    });
     const worktrees = useGitStatus(baseWorktrees, defaultBranch);
     const [sessions, setSessions] = useState([]);
     const [items, setItems] = useState([]);
@@ -53,12 +58,12 @@ const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentPro
     const worktreeConfig = configReader.getWorktreeConfig();
     useEffect(() => {
         let cancelled = false;
-        // Load worktrees and default branch using Effect composition
-        // Chain getWorktreesEffect and getDefaultBranchEffect using Effect.flatMap
-        const loadWorktreesAndBranch = Effect.flatMap(worktreeService.getWorktreesEffect(), worktrees => Effect.map(worktreeService.getDefaultBranchEffect(), defaultBranch => ({
-            worktrees,
-            defaultBranch,
-        })));
+        // These operations are independent. Run them concurrently so the initial
+        // menu load waits only for the slower command.
+        const loadWorktreesAndBranch = Effect.all({
+            worktrees: worktreeService.getWorktreesEffect(),
+            defaultBranch: worktreeService.getDefaultBranchEffect(),
+        }, { concurrency: 'unbounded' });
         Effect.runPromise(Effect.match(loadWorktreesAndBranch, {
             onFailure: (error) => ({
                 success: false,
@@ -83,17 +88,38 @@ const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentPro
                     setBaseWorktrees(result.worktrees);
                     setDefaultBranch(result.defaultBranch);
                     setLoadError(null);
+                    const snapshot = {
+                        worktrees: result.worktrees,
+                        defaultBranch: result.defaultBranch,
+                        loadError: null,
+                    };
+                    snapshotRef.current = snapshot;
+                    onSnapshotChange?.(snapshot);
                 }
                 else {
                     // Handle GitError with pattern matching
-                    setLoadError(formatGitError(result.error));
+                    const loadError = formatGitError(result.error);
+                    setLoadError(loadError);
+                    const snapshot = {
+                        ...snapshotRef.current,
+                        loadError,
+                    };
+                    snapshotRef.current = snapshot;
+                    onSnapshotChange?.(snapshot);
                 }
             }
         })
             .catch((err) => {
             // This catch should not normally be reached with Effect.match
             if (!cancelled) {
-                setLoadError(String(err));
+                const loadError = String(err);
+                setLoadError(loadError);
+                const snapshot = {
+                    ...snapshotRef.current,
+                    loadError,
+                };
+                snapshotRef.current = snapshot;
+                onSnapshotChange?.(snapshot);
             }
         });
         // Load recent projects if in multi-project mode
@@ -118,7 +144,7 @@ const Menu = ({ sessionManager, worktreeService, onMenuAction, onSelectRecentPro
             sessionManager.off('sessionDestroyed', handleSessionChange);
             sessionManager.off('sessionStateChanged', handleSessionChange);
         };
-    }, [sessionManager, worktreeService, multiProject]);
+    }, [sessionManager, worktreeService, multiProject, onSnapshotChange]);
     useEffect(() => {
         // Prepare worktree items and calculate layout
         const items = prepareSessionItems(worktrees, sessions, {

package/dist/components/Menu.test.js

@@ -183,6 +183,76 @@ describe('Menu component Effect-based error handling', () => {
         expect(getWorktreesSpy).toHaveBeenCalled();
         expect(getDefaultBranchSpy).toHaveBeenCalled();
     });
+    it('should render a cached snapshot before its background refresh completes', async () => {
+        const { Effect } = await import('effect');
+        const cachedWorktree = {
+            path: '/test/cached',
+            branch: 'cached-branch',
+            isMainWorktree: true,
+            hasSession: false,
+        };
+        const refreshedWorktree = {
+            path: '/test/refreshed',
+            branch: 'refreshed-branch',
+            isMainWorktree: true,
+            hasSession: false,
+        };
+        let resolveWorktrees;
+        const worktreesPromise = new Promise(resolve => {
+            resolveWorktrees = resolve;
+        });
+        const onSnapshotChange = vi.fn();
+        vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.promise(() => worktreesPromise));
+        const getDefaultBranchSpy = vi
+            .spyOn(worktreeService, 'getDefaultBranchEffect')
+            .mockReturnValue(Effect.succeed('main'));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, initialSnapshot: {
+                worktrees: [cachedWorktree],
+                defaultBranch: 'main',
+            }, onSnapshotChange: onSnapshotChange, onMenuAction: vi.fn(), version: "test" }));
+        // The cached rows are assembled in Menu's render effect, without waiting
+        // for the deferred Git refresh.
+        await new Promise(resolve => setTimeout(resolve, 0));
+        expect(lastFrame()).toContain('cached-branch');
+        expect(getDefaultBranchSpy).toHaveBeenCalled();
+        resolveWorktrees([refreshedWorktree]);
+        await new Promise(resolve => setTimeout(resolve, 20));
+        expect(lastFrame()).toContain('refreshed-branch');
+        expect(onSnapshotChange).toHaveBeenCalledWith({
+            worktrees: [refreshedWorktree],
+            defaultBranch: 'main',
+            loadError: null,
+        });
+    });
+    it('should retain cached worktrees when a background refresh fails', async () => {
+        const { Effect } = await import('effect');
+        const { GitError } = await import('../types/errors.js');
+        const cachedWorktree = {
+            path: '/test/cached',
+            branch: 'cached-branch',
+            isMainWorktree: true,
+            hasSession: false,
+        };
+        const onSnapshotChange = vi.fn();
+        vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.fail(new GitError({
+            command: 'git worktree list --porcelain',
+            exitCode: 1,
+            stderr: 'temporary failure',
+        })));
+        vi.spyOn(worktreeService, 'getDefaultBranchEffect').mockReturnValue(Effect.succeed('main'));
+        const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, initialSnapshot: {
+                worktrees: [cachedWorktree],
+                defaultBranch: 'main',
+            }, onSnapshotChange: onSnapshotChange, onMenuAction: vi.fn(), version: "test" }));
+        await new Promise(resolve => setTimeout(resolve, 20));
+        expect(lastFrame()).toContain('cached-branch');
+        expect(lastFrame()).toContain('temporary failure');
+        expect(onSnapshotChange).toHaveBeenCalledWith({
+            worktrees: [cachedWorktree],
+            defaultBranch: 'main',
+            loadError: expect.stringContaining('temporary failure'),
+        });
+    });
 });
 describe('Menu component rendering', () => {
     let sessionManager;

package/dist/components/Session.js

@@ -63,8 +63,14 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             session.process.write(data);
         };
         stdin.on('data', handleStdinData);
-        // Clear screen when entering session
-        stdout.write('\x1B[2J\x1B[H');
+        // Clear the viewport and the host terminal's scrollback (\x1b[3J) when
+        // entering a session. The restore snapshot then rebuilds the whole
+        // canvas — scrollback included — from this session's headless buffer,
+        // so content left behind by the menu or other sessions can never
+        // appear when the user scrolls up. \x1b[2J runs first because some
+        // emulators (e.g. xterm.js-based ones) push the erased viewport into
+        // scrollback, which \x1b[3J must then discard.
+        stdout.write('\x1B[2J\x1B[3J\x1B[H');
         // Restore the current terminal state from the headless xterm snapshot.
         // The xterm serialize addon relies on auto-wrap (DECAWM) being enabled
         // to render wrapped lines. It omits row separators for wrapped rows

package/dist/hooks/useGitStatus.d.ts

@@ -1,4 +1,6 @@
 import { Worktree } from '../types/index.js';
+/** Clear the module-level git-status cache. Intended for tests. */
+export declare function clearGitStatusCache(): void;
 /**
  * Custom hook for polling git status and commit dates of worktrees with Effect-based execution
  *

package/dist/hooks/useGitStatus.js

@@ -1,6 +1,58 @@
 import { useEffect, useState } from 'react';
 import { Effect, Exit, Cause, Option } from 'effect';
 import { getGitStatusLimited, getLastCommitDateLimited, } from '../utils/gitStatus.js';
+/**
+ * Module-level cache of the last fetched git status, keyed by worktree path.
+ *
+ * The menu is fully unmounted and remounted on every return to it (App renders
+ * `<Menu key={menuKey} />`, and the key changes on navigation), which would
+ * otherwise wipe this hook's state and force every worktree to flash
+ * "[fetching...]" and refetch from scratch each time. Seeding state from this
+ * cache shows each worktree's last known status instantly; background polling
+ * still refreshes it. Entries are intentionally not pruned so switching between
+ * projects keeps each project's cached status.
+ */
+const statusCache = new Map();
+/** Clear the module-level git-status cache. Intended for tests. */
+export function clearGitStatusCache() {
+    statusCache.clear();
+}
+/**
+ * Merge any cached status onto the given worktrees so a remount can show the
+ * last known status immediately instead of "[fetching...]". Returns the same
+ * array reference when nothing was cached, so React can skip a re-render.
+ */
+function hydrateFromCache(worktrees) {
+    let changed = false;
+    const next = worktrees.map(wt => {
+        const cached = statusCache.get(wt.path);
+        if (!cached) {
+            return wt;
+        }
+        changed = true;
+        return {
+            ...wt,
+            gitStatus: cached.gitStatus,
+            gitStatusError: cached.gitStatusError,
+            lastCommitDate: cached.lastCommitDate,
+        };
+    });
+    return changed ? next : worktrees;
+}
+/** Record a worktree's latest status update into the module-level cache. */
+function cacheStatusUpdate(path, update) {
+    const next = { ...statusCache.get(path) };
+    if ('gitStatus' in update) {
+        next.gitStatus = update.gitStatus;
+    }
+    if ('gitStatusError' in update) {
+        next.gitStatusError = update.gitStatusError;
+    }
+    if ('lastCommitDate' in update) {
+        next.lastCommitDate = update.lastCommitDate;
+    }
+    statusCache.set(path, next);
+}
 /**
  * Custom hook for polling git status and commit dates of worktrees with Effect-based execution
  *
@@ -20,7 +72,7 @@ import { getGitStatusLimited, getLastCommitDateLimited, } from '../utils/gitStat
  * @returns Array of worktrees with updated gitStatus, gitStatusError, and lastCommitDate fields
  */
 export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
-    const [worktreesWithStatus, setWorktreesWithStatus] = useState(worktrees);
+    const [worktreesWithStatus, setWorktreesWithStatus] = useState(() => hydrateFromCache(worktrees));
     useEffect(() => {
         if (!defaultBranch) {
             return;
@@ -66,7 +118,7 @@ export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
                 }, updateInterval);
             }
         };
-        setWorktreesWithStatus(worktrees);
+        setWorktreesWithStatus(hydrateFromCache(worktrees));
         runCycle().catch(() => {
             // Ignore errors - the fetch failed or was aborted
         });
@@ -97,6 +149,7 @@ function applyStatusResults(results, setWorktreesWithStatus) {
         const update = buildStatusUpdate(result.statusExit, result.dateExit);
         if (update) {
             updatesByPath.set(result.path, update);
+            cacheStatusUpdate(result.path, update);
         }
     }
     if (updatesByPath.size === 0) {

package/dist/hooks/useGitStatus.test.js

@@ -3,7 +3,7 @@ import React from 'react';
 import { render, cleanup } from 'ink-testing-library';
 import { Text } from 'ink';
 import { Effect, Exit } from 'effect';
-import { useGitStatus } from './useGitStatus.js';
+import { useGitStatus, clearGitStatusCache } from './useGitStatus.js';
 import { getGitStatusLimited, getLastCommitDateLimited, } from '../utils/gitStatus.js';
 import { GitError } from '../types/errors.js';
 // Mock the gitStatus module
@@ -29,6 +29,9 @@ describe('useGitStatus', () => {
     });
     beforeEach(() => {
         vi.useFakeTimers();
+        // The status cache is module-level and persists across tests; clear it so
+        // each test starts from a cold cache.
+        clearGitStatusCache();
         mockGetGitStatus.mockClear();
         mockGetLastCommitDate.mockClear();
         // Default: return a date for all worktrees
@@ -66,6 +69,27 @@ describe('useGitStatus', () => {
         expect(hookResult[0]?.gitStatus).toEqual(gitStatus1);
         expect(hookResult[1]?.gitStatus).toEqual(gitStatus2);
     });
+    it('should hydrate from cache on remount so status shows immediately', async () => {
+        const worktrees = [createWorktree('/path1')];
+        const gitStatus1 = createGitStatus(7, 2);
+        mockGetGitStatus.mockReturnValue(Effect.succeed(gitStatus1));
+        let hookResult = [];
+        const TestComponent = () => {
+            hookResult = useGitStatus(worktrees, 'main', 100);
+            return React.createElement(Text, null, 'test');
+        };
+        // First mount: fetch populates the module-level cache.
+        const first = render(React.createElement(TestComponent));
+        await vi.waitFor(() => {
+            expect(hookResult[0]?.gitStatus).toEqual(gitStatus1);
+        });
+        first.unmount();
+        // Remount: cached status must be present on the very first render, before
+        // any new fetch resolves, so the menu does not flash "[fetching...]".
+        hookResult = [];
+        render(React.createElement(TestComponent));
+        expect(hookResult[0]?.gitStatus).toEqual(gitStatus1);
+    });
     it('should handle empty worktree array', () => {
         let hookResult = [];
         const TestComponent = () => {

package/dist/services/sessionManager.d.ts

@@ -22,8 +22,6 @@ 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;
@@ -44,9 +42,6 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     constructor();
     private createTerminal;
     private shouldResetRestoreScrollback;
-    private hasCursorAddressedRedraw;
-    private markCursorRedrawActive;
-    private handleScrollbackGrowthDuringRedraw;
     private getRestoreSnapshot;
     private getViewportRedrawSnapshot;
     /**
@@ -94,7 +89,6 @@ 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

@@ -33,11 +33,6 @@ 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();
@@ -49,8 +44,6 @@ 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',
@@ -207,15 +200,6 @@ export class SessionManager extends EventEmitter {
             ...additionalUpdates,
         }));
         if (oldState !== newState) {
-            // While busy, cursor-addressed footer redraws (spinner, token stats,
-            // "accept edits on …" line) can push ghost frames into scrollback as
-            // chat content scrolls. Once the busy turn ends, advance the restore
-            // baseline so the next session restore replays only post-busy
-            // scrollback and skips the ghost-bearing range.
-            if (oldState === 'busy' && newState !== 'busy') {
-                session.restoreScrollbackBaseLine =
-                    session.terminal.buffer.normal.baseY;
-            }
             void Effect.runPromise(executeStatusHook(oldState, newState, session));
             this.emit('sessionStateChanged', session);
         }
@@ -238,35 +222,6 @@ 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') {
@@ -457,13 +412,8 @@ 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;
@@ -706,14 +656,6 @@ 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) {
@@ -791,7 +733,6 @@ export class SessionManager extends EventEmitter {
                 clearTimeout(resizeTimer);
                 this.resizeSuppressTimers.delete(sessionId);
             }
-            this.clearCursorRedrawTracking(sessionId);
             this.cancelRestoreDefer(sessionId);
             this.emit('sessionDestroyed', session);
         }
@@ -852,7 +793,6 @@ 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

@@ -889,7 +889,7 @@ describe('SessionManager', () => {
             mockPty.emit('data', 'ordinary output\n');
             expect(session.restoreScrollbackBaseLine).toBe(0);
         });
-        it('should skip scrollback that grows during cursor-addressed redraws', async () => {
+        it('should keep scrollback that grows during cursor-addressed redraws', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
@@ -903,38 +903,7 @@ describe('SessionManager', () => {
                 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();
-            }
+            expect(session.restoreScrollbackBaseLine).toBe(0);
         });
         it('should flush live session data after the restore snapshot completes', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
@@ -1059,7 +1028,7 @@ describe('SessionManager', () => {
                 vi.useRealTimers();
             }
         });
-        it('should advance the restore baseline when transitioning out of busy', async () => {
+        it('should retain the restore baseline when transitioning out of busy', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
@@ -1072,21 +1041,6 @@ describe('SessionManager', () => {
             await session.stateMutex.update(data => ({ ...data, state: 'busy' }));
             const updateState = sessionManager.updateSessionState.bind(sessionManager);
             await updateState(session, 'idle');
-            expect(session.restoreScrollbackBaseLine).toBe(42);
-        });
-        it('should not advance the restore baseline on transitions that do not leave busy', 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'));
-            session.terminal.buffer.normal.baseY = 42;
-            session.restoreScrollbackBaseLine = 5;
-            await session.stateMutex.update(data => ({ ...data, state: 'idle' }));
-            const updateState = sessionManager.updateSessionState.bind(sessionManager);
-            await updateState(session, 'busy');
             expect(session.restoreScrollbackBaseLine).toBe(5);
         });
     });

package/package.json

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