ccmanager 4.1.11 → 4.1.13

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,8 +18,10 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private autoApprovalDisabledWorktrees;
     private restoringSessions;
     private bufferedRestoreData;
-    private restoreRefreshTimers;
-    private restoreRefreshDeadlines;
+    private resizingSessions;
+    private resizeSuppressTimers;
+    private restoreDeferTimers;
+    private restoreDeferDeadlines;
     private spawn;
     private resolvePreset;
     detectTerminalState(session: Session): SessionState;
@@ -41,10 +43,15 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private createTerminal;
     private shouldResetRestoreScrollback;
     private getRestoreSnapshot;
-    private scheduleRestoreRefresh;
-    private armRestoreRefreshTimer;
-    private cancelRestoreRefresh;
-    private fireRestoreRefresh;
+    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
@@ -78,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,15 +21,18 @@ const { Terminal } = pkg;
 const TERMINAL_CONTENT_MAX_LINES = 300;
 const TERMINAL_SCROLLBACK_LINES = 5000;
 const TERMINAL_RESTORE_SCROLLBACK_LINES = 200;
-// Claude Code's Ink-based renderer sometimes splits a single UI redraw across
-// multiple PTY writes with short time gaps. If we snapshot between chunks, the
-// resulting viewport can miss rows (e.g. empty middle area while the top/bottom
-// chrome already rendered). Re-emit the snapshot after the PTY output has been
-// quiet for this long so late chunks are accounted for.
-const RESTORE_REFRESH_QUIET_MS = 120;
-// Cap on how long we wait for quiet before forcing the refresh, so continuous
-// streaming output (e.g. a long busy turn) still produces an updated snapshot.
-const RESTORE_REFRESH_MAX_WAIT_MS = 400;
+// 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();
@@ -37,8 +40,10 @@ export class SessionManager extends EventEmitter {
     autoApprovalDisabledWorktrees = new Set();
     restoringSessions = new Set();
     bufferedRestoreData = new Map();
-    restoreRefreshTimers = new Map();
-    restoreRefreshDeadlines = 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',
@@ -194,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);
         }
@@ -216,7 +230,7 @@ export class SessionManager extends EventEmitter {
             data.includes('\x1b[3J') ||
             data.includes('\x1bc'));
     }
-    getRestoreSnapshot(session, options = {}) {
+    getRestoreSnapshot(session) {
         const activeBuffer = session.terminal.buffer.active;
         if (activeBuffer.type !== 'normal') {
             return session.serializer.serialize({
@@ -228,21 +242,20 @@ export class SessionManager extends EventEmitter {
         if (bufferLength === 0) {
             return '';
         }
-        // While the session is busy, cursor-addressed status-box redraws can push
-        // stale frames into scrollback (e.g. Claude's spinner + token stats line).
-        // Those ghost rows render as duplicated status bars when replayed, so
-        // restore only the viewport during busy state. Refresh re-emits also
-        // bypass scrollback to avoid duplicating history into real-terminal
-        // scrollback on top of the initial emit.
-        const isBusy = session.stateMutex.getSnapshot().state === 'busy';
-        if (options.viewportOnly || isBusy) {
-            const snapshot = session.serializer.serialize({
+        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,
             });
-            const cursorRow = normalBuffer.cursorY + 1;
-            const cursorCol = normalBuffer.cursorX + 1;
-            return `${snapshot}\x1b[${cursorRow};${cursorCol}H`;
+            return `${viewportSnapshot}\x1b[${cursorRow};${cursorCol}H`;
         }
         const scrollbackStart = Math.max(0, normalBuffer.baseY - TERMINAL_RESTORE_SCROLLBACK_LINES);
         const rangeStart = Math.max(session.restoreScrollbackBaseLine, scrollbackStart);
@@ -254,59 +267,75 @@ 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`;
     }
-    scheduleRestoreRefresh(session) {
-        this.restoreRefreshDeadlines.set(session.id, Date.now() + RESTORE_REFRESH_MAX_WAIT_MS);
-        this.armRestoreRefreshTimer(session);
-    }
-    armRestoreRefreshTimer(session) {
-        const deadline = this.restoreRefreshDeadlines.get(session.id);
-        if (deadline === undefined) {
+    /**
+     * 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;
         }
-        const existing = this.restoreRefreshTimers.get(session.id);
-        if (existing !== undefined) {
-            clearTimeout(existing);
-            this.restoreRefreshTimers.delete(session.id);
+        try {
+            session.process.resize(cols, rows);
         }
-        const remaining = deadline - Date.now();
-        if (remaining <= 0) {
-            this.fireRestoreRefresh(session);
-            return;
+        catch {
+            /* empty */
         }
-        const delay = Math.min(RESTORE_REFRESH_QUIET_MS, remaining);
-        const timer = setTimeout(() => this.fireRestoreRefresh(session), delay);
-        this.restoreRefreshTimers.set(session.id, timer);
-    }
-    cancelRestoreRefresh(session) {
-        const existing = this.restoreRefreshTimers.get(session.id);
+        try {
+            session.terminal.resize(cols, rows);
+        }
+        catch {
+            /* empty */
+        }
+        this.resizingSessions.add(sessionId);
+        const existing = this.resizeSuppressTimers.get(sessionId);
         if (existing !== undefined) {
             clearTimeout(existing);
-            this.restoreRefreshTimers.delete(session.id);
         }
-        this.restoreRefreshDeadlines.delete(session.id);
-    }
-    fireRestoreRefresh(session) {
-        this.restoreRefreshTimers.delete(session.id);
-        this.restoreRefreshDeadlines.delete(session.id);
+        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.getRestoreSnapshot(session, { viewportOnly: true });
-        if (snapshot.length > 0) {
-            // \x1b[2J: clear the viewport before repainting — without this, a
-            //   refresh snapshot shorter than the already-displayed content leaves
-            //   a "ghost tail" of pre-refresh rows at the bottom.
-            // \x1b[?7h / \x1b[?7l: Session.tsx disables auto-wrap (DECAWM) after
-            //   the initial restore, but SerializeAddon omits row separators for
-            //   wrapped lines and relies on DECAWM to advance to the next row
-            //   (see PR #276). Re-enable auto-wrap just for the snapshot write so
-            //   wrapped viewport rows don't overlap, then restore the TUI default.
-            this.emit('sessionRestore', session, `\x1b[?7h\x1b[2J\x1b[H${snapshot}\x1b[?7l`);
+        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);
@@ -411,11 +440,13 @@ export class SessionManager extends EventEmitter {
                     session.terminal.buffer.normal.baseY;
             }
             session.lastActivity = new Date();
-            // If a restore-refresh is pending, each incoming chunk resets the
-            // quiet timer so the follow-up snapshot only fires after Claude's
-            // multi-chunk redraw has settled.
-            if (this.restoreRefreshDeadlines.has(session.id)) {
-                this.armRestoreRefreshTimer(session);
+            // 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) {
@@ -425,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);
             }
         });
@@ -560,31 +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.scheduleRestoreRefresh(session);
+                this.emitRestoreSnapshot(session);
             }
             else {
                 this.restoringSessions.delete(session.id);
                 this.bufferedRestoreData.delete(session.id);
-                this.cancelRestoreRefresh(session);
+                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) {
@@ -656,7 +748,13 @@ export class SessionManager extends EventEmitter {
             this.waitingWithBottomBorder.delete(sessionId);
             this.restoringSessions.delete(sessionId);
             this.bufferedRestoreData.delete(sessionId);
-            this.cancelRestoreRefresh(session);
+            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);
         }
     }
@@ -710,7 +808,13 @@ export class SessionManager extends EventEmitter {
                 }
                 this.sessions.delete(sessionId);
                 this.waitingWithBottomBorder.delete(sessionId);
-                this.cancelRestoreRefresh(session);
+                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

@@ -782,7 +782,6 @@ describe('SessionManager', () => {
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
             const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-            await session.stateMutex.update(data => ({ ...data, state: 'idle' }));
             const normalBuffer = session.terminal.buffer.normal;
             normalBuffer.baseY = 260;
             normalBuffer.length = 300;
@@ -804,32 +803,6 @@ describe('SessionManager', () => {
             });
             expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mrestored\u001b[0m\u001b[8;12H');
         });
-        it('should emit a viewport-only restore snapshot while session is 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'));
-            const normalBuffer = session.terminal.buffer.normal;
-            normalBuffer.baseY = 260;
-            normalBuffer.length = 300;
-            normalBuffer.cursorY = 7;
-            normalBuffer.cursorX = 11;
-            session.restoreScrollbackBaseLine = 120;
-            const serializeMock = vi
-                .spyOn(session.serializer, 'serialize')
-                .mockReturnValue('\u001b[31mbusy-viewport\u001b[0m');
-            const restoreHandler = vi.fn();
-            sessionManager.on('sessionRestore', restoreHandler);
-            sessionManager.setSessionActive(session.id, true);
-            expect(serializeMock).toHaveBeenCalledWith({
-                scrollback: 0,
-                excludeAltBuffer: true,
-            });
-            expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mbusy-viewport\u001b[0m\u001b[8;12H');
-        });
         it('should keep viewport-only restore behavior for alternate screen sessions', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -899,7 +872,7 @@ describe('SessionManager', () => {
             sessionManager.setSessionActive(session.id, true);
             expect(eventOrder).toEqual(['restore', 'data']);
         });
-        it('should re-emit a viewport-only snapshot after the PTY quiet period', async () => {
+        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({
@@ -909,31 +882,34 @@ describe('SessionManager', () => {
                 });
                 vi.mocked(spawn).mockReturnValue(mockPty);
                 const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-                session.terminal.buffer.normal.length = 1;
+                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('snap');
+                    .mockReturnValue('viewport');
                 const restoreHandler = vi.fn();
                 sessionManager.on('sessionRestore', restoreHandler);
                 sessionManager.setSessionActive(session.id, true);
-                expect(restoreHandler).toHaveBeenCalledTimes(1);
-                await vi.advanceTimersByTimeAsync(50);
-                mockPty.emit('data', 'late-chunk');
-                await vi.advanceTimersByTimeAsync(50);
-                expect(restoreHandler).toHaveBeenCalledTimes(1);
-                await vi.advanceTimersByTimeAsync(120);
-                expect(restoreHandler).toHaveBeenCalledTimes(2);
-                expect(restoreHandler.mock.calls[1]?.[1]).toMatch(/^\u001b\[\?7h\u001b\[2J\u001b\[Hsnap.*\u001b\[\?7l$/);
-                expect(serializeMock).toHaveBeenLastCalledWith({
+                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 force a refresh at the max-wait deadline even while data keeps streaming', async () => {
+        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({
@@ -943,23 +919,32 @@ describe('SessionManager', () => {
                 });
                 vi.mocked(spawn).mockReturnValue(mockPty);
                 const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-                session.terminal.buffer.normal.length = 1;
+                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).toHaveBeenCalledTimes(1);
-                for (let elapsed = 0; elapsed < 400; elapsed += 50) {
-                    await vi.advanceTimersByTimeAsync(50);
-                    mockPty.emit('data', 'chunk');
+                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).toHaveBeenCalledTimes(2);
+                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 scheduled refresh when the session is deactivated', async () => {
+        it('should cancel a pending deferred restore when the session is deactivated', async () => {
             vi.useFakeTimers();
             try {
                 vi.mocked(configReader.getDefaultPreset).mockReturnValue({
@@ -969,20 +954,135 @@ describe('SessionManager', () => {
                 });
                 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).toHaveBeenCalledTimes(1);
                 sessionManager.setSessionActive(session.id, false);
-                await vi.advanceTimersByTimeAsync(500);
-                expect(restoreHandler).toHaveBeenCalledTimes(1);
+                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/codex.js

@@ -15,7 +15,8 @@ export class CodexStateDetector extends BaseStateDetector {
         // Check for waiting prompts
         if (lowerContent.includes('allow command?') ||
             lowerContent.includes('[y/n]') ||
-            lowerContent.includes('yes (y)')) {
+            lowerContent.includes('yes (y)') ||
+            lowerContent.includes('enter to submit')) {
             return 'waiting_input';
         }
         if (/(do you want|would you like)[\s\S]*?\n+[\s\S]*?\byes\b/.test(lowerContent)) {

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

@@ -171,4 +171,24 @@ describe('CodexStateDetector', () => {
         // Assert
         expect(state).toBe('waiting_input');
     });
+    it('should detect waiting_input for MCP tool permission prompt with "enter to submit"', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Field 1/1',
+            'Allow the chrome-devtools MCP server to run tool "new_page"?',
+            '',
+            'timeout: 10000',
+            'url: http://localhost:4000/scenarios',
+            '',
+            '› 1. Allow                   Run the tool and continue.',
+            '2. Allow for this session  Run the tool and remember this choice for this session.',
+            '3. Always allow            Run the tool and remember this choice for future tool calls.',
+            '4. Cancel                  Cancel this tool call',
+            'enter to submit | esc to cancel',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
 });

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.11",
+	"version": "4.1.13",
 	"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.11",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.11",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.11",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.1.11",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.1.11"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.13",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.13",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.13",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.1.13",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.1.13"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",