ccmanager 4.1.12 → 4.1.14

package/dist/components/App.js

@@ -59,12 +59,12 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         };
     }, [view]);
     useInput(() => {
-        if (view !== 'worktree-hook-error' || !canReturnFromHookError) {
+        if (!canReturnFromHookError) {
             return;
         }
         setWorktreeHookError(null);
         handleReturnToMenu();
-    });
+    }, { isActive: view === 'worktree-hook-error' });
     // Helper function to format error messages based on error type using _tag discrimination
     const formatErrorMessage = (error) => {
         switch (error._tag) {

package/dist/components/Session.js

@@ -64,19 +64,33 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         // Clear screen when entering session
         stdout.write('\x1B[2J\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 and expects
-        // characters to naturally overflow to the next line, so auto-wrap must stay
-        // enabled while writing the snapshot and only be disabled afterward.
+        // The xterm serialize addon relies on auto-wrap (DECAWM) being enabled
+        // to render wrapped lines. It omits row separators for wrapped rows
+        // and expects characters to naturally overflow to the next line, so
+        // re-enable DECAWM around the snapshot write and restore the live-TUI
+        // default afterward. This matters for both the synchronous initial
+        // 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 (restoreSnapshot.length > 0) {
-                    stdout.write(restoreSnapshot);
+                    stdout.write(`\x1b[?7h${restoreSnapshot}\x1b[?7l`);
                 }
             }
         };
         // Listen for restore event first
         sessionManager.on('sessionRestore', handleSessionRestore);
+        // Repaint the user's terminal viewport from the post-resize headless
+        // snapshot. Without this, Ink-based TUIs (e.g. Claude Code) re-emit
+        // their full static history on SIGWINCH, which the user's terminal
+        // 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) {
+                stdout.write(redrawPayload);
+            }
+        };
+        sessionManager.on('sessionResize', handleSessionResize);
         // Listen for session data events
         const handleSessionData = (activeSession, data) => {
             // Only handle data for our session
@@ -120,11 +134,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         const handleResize = () => {
             const cols = process.stdout.columns || 80;
             const rows = process.stdout.rows || 24;
-            session.process.resize(cols, rows);
-            // Also resize the virtual terminal
-            if (session.terminal) {
-                session.terminal.resize(cols, rows);
-            }
+            sessionManager.performResize(session.id, cols, rows);
         };
         stdout.on('resize', handleResize);
         return () => {
@@ -138,6 +148,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             sessionManager.setSessionActive(session.id, false);
             // Remove event listeners
             sessionManager.off('sessionRestore', handleSessionRestore);
+            sessionManager.off('sessionResize', handleSessionResize);
             sessionManager.off('sessionData', handleSessionData);
             sessionManager.off('sessionExit', handleSessionExit);
             stdout.off('resize', handleResize);

package/dist/components/Session.test.js

@@ -96,7 +96,7 @@ describe('Session', () => {
         expect(terminalResize).toHaveBeenCalledWith(120, 40);
         expect(processResize.mock.invocationCallOrder[0] ?? 0).toBeLessThan(setSessionActive.mock.invocationCallOrder[0] ?? 0);
         expect(terminalResize.mock.invocationCallOrder[0] ?? 0).toBeLessThan(setSessionActive.mock.invocationCallOrder[0] ?? 0);
-        expect(testState.stdout?.write).toHaveBeenNthCalledWith(2, '\nrestored');
+        expect(testState.stdout?.write).toHaveBeenNthCalledWith(2, '\x1b[?7h\nrestored\x1b[?7l');
         expect(testState.stdout?.write).toHaveBeenNthCalledWith(3, '\x1b[?7l');
     });
 });

package/dist/services/sessionManager.d.ts

@@ -18,6 +18,10 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private autoApprovalDisabledWorktrees;
     private restoringSessions;
     private bufferedRestoreData;
+    private resizingSessions;
+    private resizeSuppressTimers;
+    private restoreDeferTimers;
+    private restoreDeferDeadlines;
     private spawn;
     private resolvePreset;
     detectTerminalState(session: Session): SessionState;
@@ -39,6 +43,15 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private createTerminal;
     private shouldResetRestoreScrollback;
     private getRestoreSnapshot;
+    private getViewportRedrawSnapshot;
+    /**
+     * Resize a session's PTY and headless terminal, then repaint the user's
+     * terminal viewport from the post-resize headless state. Live PTY → stdout
+     * forwarding is suppressed for a short window so the child's SIGWINCH
+     * redraw (which on Ink-based TUIs re-emits the full static history) cannot
+     * append duplicates below the repainted viewport.
+     */
+    performResize(sessionId: string, cols: number, rows: number): void;
     private createSessionInternal;
     /**
      * Create session with command preset using Effect-based error handling
@@ -72,6 +85,10 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     getSessionById(id: string): Session | undefined;
     getSessionsForWorktree(worktreePath: string): Session[];
     setSessionActive(sessionId: string, active: boolean): void;
+    private emitRestoreSnapshot;
+    private armRestoreDeferTimer;
+    private fireRestoreDefer;
+    private cancelRestoreDefer;
     cancelAutoApproval(sessionId: string, reason?: string): void;
     toggleAutoApprovalForWorktree(worktreePath: string): boolean;
     isAutoApprovalDisabledForWorktree(worktreePath: string): boolean;

package/dist/services/sessionManager.js

@@ -21,6 +21,18 @@ const { Terminal } = pkg;
 const TERMINAL_CONTENT_MAX_LINES = 300;
 const TERMINAL_SCROLLBACK_LINES = 5000;
 const TERMINAL_RESTORE_SCROLLBACK_LINES = 200;
+// 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.
+const RESIZE_SUPPRESS_MS = 250;
+// While a busy TUI is mid-frame across multiple PTY chunks, a synchronous
+// viewport-only restore can capture an incomplete frame and paint a half-
+// drawn screen. Defer the restore emit until PTY output has been quiet for
+// this long (extended on each chunk) so the snapshot captures a coherent
+// post-frame state. Capped by RESTORE_DEFER_MAX_MS so a continuously
+// streaming session still restores within a small bounded delay.
+const RESTORE_DEFER_QUIET_MS = 80;
+const RESTORE_DEFER_MAX_MS = 250;
 export class SessionManager extends EventEmitter {
     sessions;
     waitingWithBottomBorder = new Map();
@@ -28,6 +40,10 @@ export class SessionManager extends EventEmitter {
     autoApprovalDisabledWorktrees = new Set();
     restoringSessions = new Set();
     bufferedRestoreData = new Map();
+    resizingSessions = new Set();
+    resizeSuppressTimers = new Map();
+    restoreDeferTimers = new Map();
+    restoreDeferDeadlines = new Map();
     async spawn(command, args, worktreePath, options = {}) {
         const spawnOptions = {
             name: 'xterm-256color',
@@ -183,6 +199,15 @@ 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);
         }
@@ -217,6 +242,21 @@ export class SessionManager extends EventEmitter {
         if (bufferLength === 0) {
             return '';
         }
+        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;
@@ -227,10 +267,76 @@ export class SessionManager extends EventEmitter {
             },
             excludeAltBuffer: true,
         });
+        return `${snapshot}\x1b[${cursorRow};${cursorCol}H`;
+    }
+    getViewportRedrawSnapshot(session) {
+        const snapshot = session.serializer.serialize({ scrollback: 0 });
+        if (snapshot.length === 0) {
+            return '';
+        }
+        const activeBuffer = session.terminal.buffer.active;
+        if (activeBuffer.type !== 'normal') {
+            // Serialized alternate-buffer output already carries its own cursor
+            // positioning, so do not append a cursor home sequence here.
+            return snapshot;
+        }
+        const normalBuffer = session.terminal.buffer.normal;
         const cursorRow = normalBuffer.cursorY + 1;
         const cursorCol = normalBuffer.cursorX + 1;
         return `${snapshot}\x1b[${cursorRow};${cursorCol}H`;
     }
+    /**
+     * Resize a session's PTY and headless terminal, then repaint the user's
+     * terminal viewport from the post-resize headless state. Live PTY → stdout
+     * forwarding is suppressed for a short window so the child's SIGWINCH
+     * redraw (which on Ink-based TUIs re-emits the full static history) cannot
+     * append duplicates below the repainted viewport.
+     */
+    performResize(sessionId, cols, rows) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        try {
+            session.process.resize(cols, rows);
+        }
+        catch {
+            /* empty */
+        }
+        try {
+            session.terminal.resize(cols, rows);
+        }
+        catch {
+            /* empty */
+        }
+        this.resizingSessions.add(sessionId);
+        const existing = this.resizeSuppressTimers.get(sessionId);
+        if (existing !== undefined) {
+            clearTimeout(existing);
+        }
+        const timer = setTimeout(() => {
+            this.resizeSuppressTimers.delete(sessionId);
+            this.resizingSessions.delete(sessionId);
+        }, RESIZE_SUPPRESS_MS);
+        this.resizeSuppressTimers.set(sessionId, timer);
+        if (!session.isActive) {
+            return;
+        }
+        const snapshot = this.getViewportRedrawSnapshot(session);
+        if (snapshot.length === 0) {
+            return;
+        }
+        // \x1b[?7h ... \x1b[?7l: SerializeAddon's wrapped-row encoding relies
+        //   on auto-wrap (DECAWM) being enabled to advance the cursor across
+        //   row boundaries (see PR #276). Session.tsx keeps DECAWM disabled
+        //   for live TUI redraws, so re-enable it just for the snapshot write
+        //   and restore the live default afterward.
+        // \x1b[2J\x1b[H: clear the post-resize viewport so the snapshot paints
+        //   onto a known canvas; rows that the child won't cover (e.g. trailing
+        //   blanks after a height shrink) stay clean rather than retaining
+        //   pre-resize content.
+        this.emit('sessionResize', session, `\x1b[?7h\x1b[2J\x1b[H${snapshot}\x1b[?7l`);
+    }
     async createSessionInternal(worktreePath, ptyProcess, options = {}) {
         const existingSessions = this.getSessionsForWorktree(worktreePath);
         const maxNumber = existingSessions.reduce((max, s) => Math.max(max, s.sessionNumber), 0);
@@ -334,6 +440,14 @@ export class SessionManager extends EventEmitter {
                     session.terminal.buffer.normal.baseY;
             }
             session.lastActivity = new Date();
+            // Deferred restore is waiting for the TUI to finish a frame. Reset
+            // the quiet timer with each chunk; the snapshot fired at the end of
+            // the quiet window will already include this data through the
+            // headless write above, so do not buffer or forward.
+            if (this.restoreDeferDeadlines.has(session.id)) {
+                this.armRestoreDeferTimer(session);
+                return;
+            }
             // Only emit data events when session is active
             if (session.isActive) {
                 if (this.restoringSessions.has(session.id)) {
@@ -342,6 +456,15 @@ export class SessionManager extends EventEmitter {
                     this.bufferedRestoreData.set(session.id, bufferedData);
                     return;
                 }
+                // During a viewport resize, the child process re-emits its full
+                // static content to adapt to new line-wrapping. The headless
+                // terminal already absorbed the data above, so the post-resize
+                // snapshot we wrote on resize is in sync. Drop the live forward
+                // here to keep the user's terminal from acquiring duplicated
+                // rows below the snapshot.
+                if (this.resizingSessions.has(session.id)) {
+                    return;
+                }
                 this.emit('sessionData', session, data);
             }
         });
@@ -477,29 +600,83 @@ export class SessionManager extends EventEmitter {
             if (active) {
                 session.lastAccessedAt = Date.now();
                 this.restoringSessions.add(session.id);
-                try {
-                    const restoreSnapshot = this.getRestoreSnapshot(session);
-                    if (restoreSnapshot.length > 0) {
-                        this.emit('sessionRestore', session, restoreSnapshot);
-                    }
-                }
-                finally {
-                    this.restoringSessions.delete(session.id);
-                    const bufferedData = this.bufferedRestoreData.get(session.id);
-                    if (bufferedData && bufferedData.length > 0) {
-                        this.bufferedRestoreData.delete(session.id);
-                        for (const chunk of bufferedData) {
-                            this.emit('sessionData', session, chunk);
-                        }
-                    }
+                // While the TUI shows a busy footer it may be mid-frame across
+                // multiple PTY chunks; capturing the snapshot synchronously can
+                // surface a half-drawn viewport. Defer until PTY output is
+                // quiet so the snapshot reflects a coherent post-frame state.
+                if (session.stateDetector.hasTransientRenderFooter(session.terminal)) {
+                    this.restoreDeferDeadlines.set(session.id, Date.now() + RESTORE_DEFER_MAX_MS);
+                    this.armRestoreDeferTimer(session);
+                    return;
                 }
+                this.emitRestoreSnapshot(session);
             }
             else {
                 this.restoringSessions.delete(session.id);
                 this.bufferedRestoreData.delete(session.id);
+                this.resizingSessions.delete(session.id);
+                const resizeTimer = this.resizeSuppressTimers.get(session.id);
+                if (resizeTimer !== undefined) {
+                    clearTimeout(resizeTimer);
+                    this.resizeSuppressTimers.delete(session.id);
+                }
+                this.cancelRestoreDefer(session.id);
+            }
+        }
+    }
+    emitRestoreSnapshot(session) {
+        try {
+            const restoreSnapshot = this.getRestoreSnapshot(session);
+            if (restoreSnapshot.length > 0) {
+                this.emit('sessionRestore', session, restoreSnapshot);
+            }
+        }
+        finally {
+            this.restoringSessions.delete(session.id);
+            const bufferedData = this.bufferedRestoreData.get(session.id);
+            if (bufferedData && bufferedData.length > 0) {
+                this.bufferedRestoreData.delete(session.id);
+                for (const chunk of bufferedData) {
+                    this.emit('sessionData', session, chunk);
+                }
             }
         }
     }
+    armRestoreDeferTimer(session) {
+        const deadline = this.restoreDeferDeadlines.get(session.id);
+        if (deadline === undefined) {
+            return;
+        }
+        const existing = this.restoreDeferTimers.get(session.id);
+        if (existing !== undefined) {
+            clearTimeout(existing);
+        }
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            this.fireRestoreDefer(session);
+            return;
+        }
+        const delay = Math.min(RESTORE_DEFER_QUIET_MS, remaining);
+        const timer = setTimeout(() => this.fireRestoreDefer(session), delay);
+        this.restoreDeferTimers.set(session.id, timer);
+    }
+    fireRestoreDefer(session) {
+        this.restoreDeferTimers.delete(session.id);
+        this.restoreDeferDeadlines.delete(session.id);
+        if (!session.isActive) {
+            this.restoringSessions.delete(session.id);
+            return;
+        }
+        this.emitRestoreSnapshot(session);
+    }
+    cancelRestoreDefer(sessionId) {
+        const timer = this.restoreDeferTimers.get(sessionId);
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            this.restoreDeferTimers.delete(sessionId);
+        }
+        this.restoreDeferDeadlines.delete(sessionId);
+    }
     cancelAutoApproval(sessionId, reason = 'User input received') {
         const session = this.sessions.get(sessionId);
         if (!session) {
@@ -571,6 +748,13 @@ export class SessionManager extends EventEmitter {
             this.waitingWithBottomBorder.delete(sessionId);
             this.restoringSessions.delete(sessionId);
             this.bufferedRestoreData.delete(sessionId);
+            this.resizingSessions.delete(sessionId);
+            const resizeTimer = this.resizeSuppressTimers.get(sessionId);
+            if (resizeTimer !== undefined) {
+                clearTimeout(resizeTimer);
+                this.resizeSuppressTimers.delete(sessionId);
+            }
+            this.cancelRestoreDefer(sessionId);
             this.emit('sessionDestroyed', session);
         }
     }
@@ -624,6 +808,13 @@ export class SessionManager extends EventEmitter {
                 }
                 this.sessions.delete(sessionId);
                 this.waitingWithBottomBorder.delete(sessionId);
+                this.resizingSessions.delete(sessionId);
+                const resizeTimer = this.resizeSuppressTimers.get(sessionId);
+                if (resizeTimer !== undefined) {
+                    clearTimeout(resizeTimer);
+                    this.resizeSuppressTimers.delete(sessionId);
+                }
+                this.cancelRestoreDefer(sessionId);
                 this.emit('sessionDestroyed', session);
             },
             catch: (error) => {

package/dist/services/sessionManager.test.js

@@ -872,6 +872,217 @@ 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 () => {
+            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 = 260;
+                normalBuffer.length = 300;
+                normalBuffer.cursorY = 7;
+                normalBuffer.cursorX = 11;
+                session.restoreScrollbackBaseLine = 120;
+                vi.spyOn(session.stateDetector, 'hasTransientRenderFooter').mockReturnValue(true);
+                const serializeMock = vi
+                    .spyOn(session.serializer, 'serialize')
+                    .mockReturnValue('viewport');
+                const restoreHandler = vi.fn();
+                sessionManager.on('sessionRestore', restoreHandler);
+                sessionManager.setSessionActive(session.id, true);
+                expect(restoreHandler).not.toHaveBeenCalled();
+                expect(serializeMock).not.toHaveBeenCalled();
+                vi.advanceTimersByTime(80);
+                expect(serializeMock).toHaveBeenCalledWith({
+                    scrollback: 0,
+                    excludeAltBuffer: true,
+                });
+                expect(serializeMock).not.toHaveBeenCalledWith(expect.objectContaining({ range: expect.anything() }));
+                expect(restoreHandler).toHaveBeenCalledWith(session, 'viewport');
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+        it('should extend the restore quiet timer while PTY output keeps streaming, capped by the deadline', 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'));
+                session.terminal.buffer.normal.length =
+                    1;
+                vi.spyOn(session.stateDetector, 'hasTransientRenderFooter').mockReturnValue(true);
+                vi.spyOn(session.serializer, 'serialize').mockReturnValue('snap');
+                const restoreHandler = vi.fn();
+                sessionManager.on('sessionRestore', restoreHandler);
+                sessionManager.setSessionActive(session.id, true);
+                expect(restoreHandler).not.toHaveBeenCalled();
+                // Each chunk arrives within the quiet window and resets the timer
+                // without firing the snapshot. Three 50 ms ticks keep the cap
+                // (250 ms) safely ahead.
+                for (let i = 0; i < 3; i++) {
+                    vi.advanceTimersByTime(50);
+                    mockPty.emit('data', 'tick');
+                }
+                expect(restoreHandler).not.toHaveBeenCalled();
+                // Advance past the cap so the snapshot fires even though chunks
+                // kept arriving inside the quiet window.
+                vi.advanceTimersByTime(150);
+                expect(restoreHandler).toHaveBeenCalledTimes(1);
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+        it('should cancel a pending deferred restore when the session is deactivated', 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'));
+                vi.spyOn(session.stateDetector, 'hasTransientRenderFooter').mockReturnValue(true);
+                vi.spyOn(session.serializer, 'serialize').mockReturnValue('snap');
+                const restoreHandler = vi.fn();
+                sessionManager.on('sessionRestore', restoreHandler);
+                sessionManager.setSessionActive(session.id, true);
+                sessionManager.setSessionActive(session.id, false);
+                vi.advanceTimersByTime(500);
+                expect(restoreHandler).not.toHaveBeenCalled();
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+        it('should advance the restore baseline when transitioning out of 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: '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);
+        });
+    });
+    describe('performResize', () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+        it('emits a wrapped viewport snapshot to repaint after resize', 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.isActive = true;
+            const normalBuffer = session.terminal.buffer.normal;
+            normalBuffer.cursorY = 3;
+            normalBuffer.cursorX = 4;
+            const serializeMock = vi
+                .spyOn(session.serializer, 'serialize')
+                .mockReturnValue('VIEWPORT');
+            const resizeHandler = vi.fn();
+            sessionManager.on('sessionResize', resizeHandler);
+            sessionManager.performResize(session.id, 100, 24);
+            expect(session.process.resize).toHaveBeenCalledWith(100, 24);
+            expect(session.terminal.resize).toHaveBeenCalledWith(100, 24);
+            expect(serializeMock).toHaveBeenCalledWith({ scrollback: 0 });
+            expect(resizeHandler).toHaveBeenCalledWith(session, '[?7hVIEWPORT[?7l');
+        });
+        it('suppresses live PTY → stdout forwarding for the post-resize quiet window', 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.isActive = true;
+            vi.spyOn(session.serializer, 'serialize').mockReturnValue('VIEWPORT');
+            const dataHandler = vi.fn();
+            sessionManager.on('sessionData', dataHandler);
+            sessionManager.performResize(session.id, 100, 24);
+            mockPty.emit('data', 'static-replay');
+            expect(dataHandler).not.toHaveBeenCalled();
+            vi.advanceTimersByTime(260);
+            mockPty.emit('data', 'live-after-window');
+            expect(dataHandler).toHaveBeenCalledTimes(1);
+            expect(dataHandler).toHaveBeenCalledWith(session, 'live-after-window');
+        });
+        it('skips emitting a resize repaint for inactive sessions', 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.isActive = false;
+            vi.spyOn(session.serializer, 'serialize').mockReturnValue('VIEWPORT');
+            const resizeHandler = vi.fn();
+            sessionManager.on('sessionResize', resizeHandler);
+            sessionManager.performResize(session.id, 100, 24);
+            expect(resizeHandler).not.toHaveBeenCalled();
+            expect(session.process.resize).toHaveBeenCalledWith(100, 24);
+        });
+        it('clears the resize suppression when the session is deactivated', 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.isActive = true;
+            vi.spyOn(session.serializer, 'serialize').mockReturnValue('VIEWPORT');
+            const dataHandler = vi.fn();
+            sessionManager.on('sessionData', dataHandler);
+            sessionManager.performResize(session.id, 100, 24);
+            sessionManager.setSessionActive(session.id, false);
+            session.isActive = true;
+            mockPty.emit('data', 'live-after-deactivate');
+            expect(dataHandler).toHaveBeenCalledTimes(1);
+            expect(dataHandler).toHaveBeenCalledWith(session, 'live-after-deactivate');
+        });
     });
     describe('static methods', () => {
         describe('getSessionCounts', () => {

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

@@ -6,4 +6,5 @@ export declare abstract class BaseStateDetector implements StateDetector {
     protected getTerminalContent(terminal: Terminal, maxLines: number): string;
     abstract detectBackgroundTask(terminal: Terminal): number;
     abstract detectTeamMembers(terminal: Terminal): number;
+    hasTransientRenderFooter(_terminal: Terminal): boolean;
 }

package/dist/services/stateDetector/base.js

@@ -7,4 +7,7 @@ export class BaseStateDetector {
     getTerminalContent(terminal, maxLines) {
         return getTerminalScreenContent(terminal, maxLines);
     }
+    hasTransientRenderFooter(_terminal) {
+        return false;
+    }
 }

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

@@ -33,5 +33,6 @@ export declare class ClaudeStateDetector extends BaseStateDetector {
     private getRecentContentAbovePromptBox;
     detectState(terminal: Terminal, currentState: SessionState): SessionState;
     detectBackgroundTask(terminal: Terminal): number;
+    hasTransientRenderFooter(terminal: Terminal): boolean;
     detectTeamMembers(terminal: Terminal): number;
 }

package/dist/services/stateDetector/claude.js

@@ -145,6 +145,31 @@ export class ClaudeStateDetector extends BaseStateDetector {
         // No background task detected
         return 0;
     }
+    hasTransientRenderFooter(terminal) {
+        // Only flag busy-turn footer markers. The persistent "(shift+tab to
+        // cycle)" footer is always visible during an active Claude session
+        // even when idle, but it does not by itself indicate that recent
+        // scrolling pushed ghost frames into scrollback — only an in-flight
+        // busy turn does. busy → non-busy transitions advance the restore
+        // baseline separately so already-scrolled ghosts from a just-ended
+        // turn are not replayed either.
+        const viewport = this.getTerminalContent(terminal, terminal.rows);
+        if (viewport.length === 0) {
+            return false;
+        }
+        if (SPINNER_ACTIVITY_PATTERN.test(viewport)) {
+            return true;
+        }
+        if (TOKEN_STATS_LINE_PATTERN.test(viewport)) {
+            return true;
+        }
+        const lower = viewport.toLowerCase();
+        if (lower.includes('esc to interrupt') ||
+            lower.includes('ctrl+c to interrupt')) {
+            return true;
+        }
+        return false;
+    }
     detectTeamMembers(terminal) {
         const lines = this.getTerminalLines(terminal, 3);
         // Look for the team member line containing "shift+↑ to expand"

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

@@ -778,6 +778,62 @@ describe('ClaudeStateDetector', () => {
             expect(count).toBe(3);
         });
     });
+    describe('hasTransientRenderFooter', () => {
+        it('returns true when viewport contains spinner activity label', () => {
+            terminal = createMockTerminal([
+                '✶ Befuddling… (1m 1s · ↓ 283 tokens)',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
+            ]);
+            expect(detector.hasTransientRenderFooter(terminal)).toBe(true);
+        });
+        it('returns true when viewport contains a token stats line', () => {
+            terminal = createMockTerminal([
+                '(9m 21s · ↓ 13.7k tokens)',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
+            ]);
+            expect(detector.hasTransientRenderFooter(terminal)).toBe(true);
+        });
+        it('returns false for a steady idle viewport that only shows the persistent shift+tab footer', () => {
+            // The "(shift+tab to cycle)" line is rendered even when nothing
+            // is scrolling, so on its own it does not imply scrollback ghosts.
+            terminal = createMockTerminal([
+                'Some idle conversation',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
+                '⏵⏵ accept edits on (shift+tab to cycle)',
+            ]);
+            expect(detector.hasTransientRenderFooter(terminal)).toBe(false);
+        });
+        it('returns true when viewport contains "esc to interrupt"', () => {
+            terminal = createMockTerminal([
+                'Working...',
+                'Press esc to interrupt',
+                '❯',
+            ]);
+            expect(detector.hasTransientRenderFooter(terminal)).toBe(true);
+        });
+        it('returns true when viewport contains "ctrl+c to interrupt"', () => {
+            terminal = createMockTerminal(['Searching… (ctrl+c to interrupt)', '❯']);
+            expect(detector.hasTransientRenderFooter(terminal)).toBe(true);
+        });
+        it('returns false on a quiet idle viewport without footer markers', () => {
+            terminal = createMockTerminal([
+                'Some output',
+                'Command completed successfully',
+                '> ',
+            ]);
+            expect(detector.hasTransientRenderFooter(terminal)).toBe(false);
+        });
+        it('returns false for an empty terminal', () => {
+            terminal = createMockTerminal([]);
+            expect(detector.hasTransientRenderFooter(terminal)).toBe(false);
+        });
+    });
     describe('detectTeamMembers', () => {
         it('should return 2 when two @name members are present with shift+↑ to expand', () => {
             terminal = createMockTerminal([

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

@@ -3,4 +3,5 @@ export interface StateDetector {
     detectState(terminal: Terminal, currentState: SessionState): SessionState;
     detectBackgroundTask(terminal: Terminal): number;
     detectTeamMembers(terminal: Terminal): number;
+    hasTransientRenderFooter(terminal: Terminal): boolean;
 }

package/package.json

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