ccmanager 4.1.5 → 4.1.7

package/dist/components/Session.js

@@ -65,9 +65,9 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         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, expecting
-        // characters to naturally overflow to the next line.  We therefore keep
-        // auto-wrap enabled while writing the snapshot and only disable it afterward.
+        // 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.
         const handleSessionRestore = (restoredSession, restoreSnapshot) => {
             if (restoredSession.id === session.id) {
                 if (restoreSnapshot.length > 0) {
@@ -109,15 +109,12 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             /* empty */
         }
         // Mark session as active after resizing so the restore snapshot matches
-        // the current terminal dimensions.  setSessionActive synchronously emits
-        // the 'sessionRestore' event, so the snapshot is written to stdout before
-        // we proceed.
+        // the current terminal dimensions. setSessionActive synchronously emits the
+        // restore event, so the snapshot is written to stdout before we proceed.
         sessionManager.setSessionActive(session.id, true);
         // Prevent line wrapping from drifting redraws in TUIs that rely on
-        // cursor-up clears.  This MUST come after the restore snapshot write
-        // because the xterm serialize addon relies on auto-wrap (DECAWM) being
-        // enabled — it omits row separators for wrapped rows, expecting characters
-        // to naturally overflow to the next line.
+        // cursor-up clears. This must happen after the restore snapshot write,
+        // otherwise wrapped restore content can overlap on the same row.
         stdout.write('\x1b[?7l');
         // Handle terminal resize
         const handleResize = () => {

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

@@ -1,8 +1,13 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { EventEmitter } from 'events';
 import { spawn } from './bunTerminal.js';
-import { STATE_PERSISTENCE_DURATION_MS, STATE_MINIMUM_DURATION_MS, } from '../constants/statePersistence.js';
 import { Effect, Either } from 'effect';
+/**
+ * Must match `STATE_CHECK_INTERVAL_MS` in sessionManager.ts.
+ * State updates are async; the next interval tick sees the new state and runs auto-approval.
+ */
+const STATE_CHECK_INTERVAL_MS = 100;
+const STATE_DETECTION_TICKS_FOR_ASYNC_UPDATE = 2;
 const detectStateMock = vi.fn();
 // Create a deferred promise pattern for controllable mock
 let verifyResolve = null;
@@ -64,13 +69,25 @@ vi.mock('@xterm/addon-serialize', () => ({
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn().mockImplementation(function () {
+            const normalBuffer = {
+                type: 'normal',
+                baseY: 0,
+                cursorY: 0,
+                cursorX: 0,
+                length: 0,
+                getLine: vi.fn(),
+            };
             return {
                 rows: 24,
                 cols: 80,
                 buffer: {
-                    active: {
-                        type: 'normal',
+                    active: normalBuffer,
+                    normal: normalBuffer,
+                    alternate: {
+                        type: 'alternate',
                         baseY: 0,
+                        cursorY: 0,
+                        cursorX: 0,
                         length: 0,
                         getLine: vi.fn(),
                     },
@@ -139,17 +156,17 @@ describe('SessionManager - Auto Approval Recovery', () => {
         }));
         // Phase 1: waiting_input (auto-approval suppressed due to prior failure)
         detectStateMock.mockReturnValue('waiting_input');
-        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * STATE_DETECTION_TICKS_FOR_ASYNC_UPDATE);
         expect(session.stateMutex.getSnapshot().state).toBe('waiting_input');
         expect(session.stateMutex.getSnapshot().autoApprovalFailed).toBe(true);
         // Phase 2: busy - should reset the failure flag
         detectStateMock.mockReturnValue('busy');
-        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * STATE_DETECTION_TICKS_FOR_ASYNC_UPDATE);
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         expect(session.stateMutex.getSnapshot().autoApprovalFailed).toBe(false);
         // Phase 3: waiting_input again - should trigger pending_auto_approval
         detectStateMock.mockReturnValue('waiting_input');
-        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * STATE_DETECTION_TICKS_FOR_ASYNC_UPDATE);
         // State should now be pending_auto_approval (waiting for verification)
         expect(session.stateMutex.getSnapshot().state).toBe('pending_auto_approval');
         expect(verifyNeedsPermissionMock).toHaveBeenCalled();
@@ -165,8 +182,6 @@ describe('SessionManager - Auto Approval Recovery', () => {
             ...data,
             state: 'pending_auto_approval',
             autoApprovalAbortController: abortController,
-            pendingState: 'pending_auto_approval',
-            pendingStateStart: Date.now(),
         }));
         const handler = vi.fn();
         sessionManager.on('sessionStateChanged', handler);
@@ -181,7 +196,6 @@ describe('SessionManager - Auto Approval Recovery', () => {
         expect(stateData.autoApprovalAbortController).toBeUndefined();
         expect(stateData.autoApprovalFailed).toBe(true);
         expect(stateData.state).toBe('waiting_input');
-        expect(stateData.pendingState).toBeUndefined();
         expect(handler).toHaveBeenCalledWith(session);
         sessionManager.off('sessionStateChanged', handler);
     });
@@ -193,7 +207,7 @@ describe('SessionManager - Auto Approval Recovery', () => {
         sessionManager.on('sessionStateChanged', handler);
         // Phase 1: waiting_input → pending_auto_approval
         detectStateMock.mockReturnValue('waiting_input');
-        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * STATE_DETECTION_TICKS_FOR_ASYNC_UPDATE);
         // State should be pending_auto_approval (waiting for verification)
         expect(session.stateMutex.getSnapshot().state).toBe('pending_auto_approval');
         expect(verifyNeedsPermissionMock).toHaveBeenCalled();
@@ -204,8 +218,6 @@ describe('SessionManager - Auto Approval Recovery', () => {
         await vi.waitFor(() => {
             expect(session.stateMutex.getSnapshot().state).toBe('busy');
         });
-        expect(session.stateMutex.getSnapshot().pendingState).toBeUndefined();
-        expect(session.stateMutex.getSnapshot().pendingStateStart).toBeUndefined();
         // Verify Enter key was sent to approve
         expect(mockPty.write).toHaveBeenCalledWith('\r');
         // Verify sessionStateChanged was emitted with session containing state=busy

package/dist/services/sessionManager.d.ts

@@ -16,6 +16,8 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private waitingWithBottomBorder;
     private busyTimers;
     private autoApprovalDisabledWorktrees;
+    private restoringSessions;
+    private bufferedRestoreData;
     private spawn;
     private resolvePreset;
     detectTerminalState(session: Session): SessionState;
@@ -35,6 +37,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private updateSessionState;
     constructor();
     private createTerminal;
+    private shouldResetRestoreScrollback;
     private getRestoreSnapshot;
     private createSessionInternal;
     /**

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

@@ -46,13 +46,25 @@ vi.mock('@xterm/addon-serialize', () => ({
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn().mockImplementation(function () {
+            const normalBuffer = {
+                type: 'normal',
+                baseY: 0,
+                cursorY: 0,
+                cursorX: 0,
+                length: 0,
+                getLine: vi.fn(),
+            };
             return {
                 rows: 24,
                 cols: 80,
                 buffer: {
-                    active: {
-                        type: 'normal',
+                    active: normalBuffer,
+                    normal: normalBuffer,
+                    alternate: {
+                        type: 'alternate',
                         baseY: 0,
+                        cursorY: 0,
+                        cursorX: 0,
                         length: 0,
                         getLine: vi.fn(),
                     },

package/dist/services/sessionManager.js

@@ -6,7 +6,8 @@ import { spawn as childSpawn } from 'child_process';
 import { configReader } from './config/configReader.js';
 import { executeStatusHook } from '../utils/hookExecutor.js';
 import { createStateDetector } from './stateDetector/index.js';
-import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, STATE_MINIMUM_DURATION_MS, } from '../constants/statePersistence.js';
+/** Interval in milliseconds for polling terminal state detection. */
+const STATE_CHECK_INTERVAL_MS = 100;
 import { Effect, Either } from 'effect';
 import { ProcessError, ConfigError } from '../types/errors.js';
 import { autoApprovalVerifier } from './autoApprovalVerifier.js';
@@ -19,11 +20,14 @@ import { preparePresetLaunch } from '../utils/presetPrompt.js';
 const { Terminal } = pkg;
 const TERMINAL_CONTENT_MAX_LINES = 300;
 const TERMINAL_SCROLLBACK_LINES = 5000;
+const TERMINAL_RESTORE_SCROLLBACK_LINES = 200;
 export class SessionManager extends EventEmitter {
     sessions;
     waitingWithBottomBorder = new Map();
     busyTimers = new Map();
     autoApprovalDisabledWorktrees = new Set();
+    restoringSessions = new Set();
+    bufferedRestoreData = new Map();
     async spawn(command, args, worktreePath, options = {}) {
         const spawnOptions = {
             name: 'xterm-256color',
@@ -176,9 +180,6 @@ export class SessionManager extends EventEmitter {
         await session.stateMutex.update(data => ({
             ...data,
             state: newState,
-            pendingState: undefined,
-            pendingStateStart: undefined,
-            stateConfirmedAt: Date.now(),
             ...additionalUpdates,
         }));
         if (oldState !== newState) {
@@ -199,10 +200,36 @@ export class SessionManager extends EventEmitter {
             logLevel: 'off',
         });
     }
+    shouldResetRestoreScrollback(data) {
+        return (data.includes('\x1b[2J') ||
+            data.includes('\x1b[3J') ||
+            data.includes('\x1bc'));
+    }
     getRestoreSnapshot(session) {
-        return session.serializer.serialize({
-            scrollback: 0,
+        const activeBuffer = session.terminal.buffer.active;
+        if (activeBuffer.type !== 'normal') {
+            return session.serializer.serialize({
+                scrollback: 0,
+            });
+        }
+        const normalBuffer = session.terminal.buffer.normal;
+        const bufferLength = normalBuffer.length;
+        if (bufferLength === 0) {
+            return '';
+        }
+        const scrollbackStart = Math.max(0, normalBuffer.baseY - TERMINAL_RESTORE_SCROLLBACK_LINES);
+        const rangeStart = Math.max(session.restoreScrollbackBaseLine, scrollbackStart);
+        const rangeEnd = bufferLength - 1;
+        const snapshot = session.serializer.serialize({
+            range: {
+                start: rangeStart,
+                end: rangeEnd,
+            },
+            excludeAltBuffer: true,
         });
+        const cursorRow = normalBuffer.cursorY + 1;
+        const cursorCol = normalBuffer.cursorX + 1;
+        return `${snapshot}\x1b[${cursorRow};${cursorCol}H`;
     }
     async createSessionInternal(worktreePath, ptyProcess, options = {}) {
         const existingSessions = this.getSessionsForWorktree(worktreePath);
@@ -226,6 +253,7 @@ export class SessionManager extends EventEmitter {
             isActive: false,
             terminal,
             serializer,
+            restoreScrollbackBaseLine: 0,
             stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
             presetName: options.presetName,
@@ -301,9 +329,19 @@ export class SessionManager extends EventEmitter {
         session.process.onData((data) => {
             // Write data to virtual terminal
             session.terminal.write(data);
+            if (this.shouldResetRestoreScrollback(data)) {
+                session.restoreScrollbackBaseLine =
+                    session.terminal.buffer.normal.baseY;
+            }
             session.lastActivity = new Date();
             // Only emit data events when session is active
             if (session.isActive) {
+                if (this.restoringSessions.has(session.id)) {
+                    const bufferedData = this.bufferedRestoreData.get(session.id) ?? [];
+                    bufferedData.push(data);
+                    this.bufferedRestoreData.set(session.id, bufferedData);
+                    return;
+                }
                 this.emit('sessionData', session, data);
             }
         });
@@ -361,60 +399,27 @@ export class SessionManager extends EventEmitter {
     setupBackgroundHandler(session) {
         // Setup data handler
         this.setupDataHandler(session);
-        // Set up interval-based state detection with persistence
+        // Set up interval-based state detection
         session.stateCheckInterval = setInterval(() => {
             const stateData = session.stateMutex.getSnapshot();
             const oldState = stateData.state;
             const detectedState = this.detectTerminalState(session);
-            const now = Date.now();
-            // If detected state is different from current state
             if (detectedState !== oldState) {
-                // If this is a new pending state or the pending state changed
-                if (stateData.pendingState !== detectedState) {
-                    void session.stateMutex.update(data => ({
-                        ...data,
-                        pendingState: detectedState,
-                        pendingStateStart: now,
-                    }));
+                // Cancel auto-approval verification if state is changing away from pending_auto_approval
+                if (stateData.autoApprovalAbortController &&
+                    detectedState !== 'pending_auto_approval') {
+                    this.cancelAutoApprovalVerification(session, `state changed to ${detectedState}`);
                 }
-                else if (stateData.pendingState !== undefined &&
-                    stateData.pendingStateStart !== undefined) {
-                    // Check if the pending state has persisted long enough
-                    // and that the current state has been active for the minimum duration
-                    const duration = now - stateData.pendingStateStart;
-                    const timeInCurrentState = now - stateData.stateConfirmedAt;
-                    if (duration >= STATE_PERSISTENCE_DURATION_MS &&
-                        timeInCurrentState >= STATE_MINIMUM_DURATION_MS) {
-                        // Cancel auto-approval verification if state is changing away from pending_auto_approval
-                        if (stateData.autoApprovalAbortController &&
-                            detectedState !== 'pending_auto_approval') {
-                            this.cancelAutoApprovalVerification(session, `state changed to ${detectedState}`);
-                        }
-                        // Build additional updates for auto-approval reset
-                        const additionalUpdates = {};
-                        // If we previously blocked auto-approval and have moved out of a user prompt,
-                        // allow future auto-approval attempts.
-                        if (stateData.autoApprovalFailed &&
-                            detectedState !== 'waiting_input' &&
-                            detectedState !== 'pending_auto_approval') {
-                            additionalUpdates.autoApprovalFailed = false;
-                            additionalUpdates.autoApprovalReason = undefined;
-                        }
-                        // Confirm the state change with hook execution
-                        void this.updateSessionState(session, detectedState, additionalUpdates);
-                    }
+                const additionalUpdates = {};
+                // If we previously blocked auto-approval and have moved out of a user prompt,
+                // allow future auto-approval attempts.
+                if (stateData.autoApprovalFailed &&
+                    detectedState !== 'waiting_input' &&
+                    detectedState !== 'pending_auto_approval') {
+                    additionalUpdates.autoApprovalFailed = false;
+                    additionalUpdates.autoApprovalReason = undefined;
                 }
-            }
-            else {
-                // Detected state matches current state, clear any pending state
-                // and update stateConfirmedAt so the minimum duration guard
-                // tracks "last time current state was seen" rather than "first confirmed"
-                void session.stateMutex.update(data => ({
-                    ...data,
-                    pendingState: undefined,
-                    pendingStateStart: undefined,
-                    stateConfirmedAt: now,
-                }));
+                void this.updateSessionState(session, detectedState, additionalUpdates);
             }
             // Handle auto-approval if state is pending_auto_approval and no verification is in progress.
             // This ensures auto-approval is retried when the state remains pending_auto_approval
@@ -471,10 +476,27 @@ export class SessionManager extends EventEmitter {
             session.isActive = active;
             if (active) {
                 session.lastAccessedAt = Date.now();
-                const restoreSnapshot = this.getRestoreSnapshot(session);
-                if (restoreSnapshot.length > 0) {
-                    this.emit('sessionRestore', session, restoreSnapshot);
+                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);
+                        }
+                    }
+                }
+            }
+            else {
+                this.restoringSessions.delete(session.id);
+                this.bufferedRestoreData.delete(session.id);
             }
         }
     }
@@ -502,8 +524,6 @@ export class SessionManager extends EventEmitter {
                 ...data,
                 autoApprovalFailed: true,
                 autoApprovalReason: reason,
-                pendingState: undefined,
-                pendingStateStart: undefined,
             }));
         }
     }
@@ -549,6 +569,8 @@ export class SessionManager extends EventEmitter {
             }
             this.sessions.delete(sessionId);
             this.waitingWithBottomBorder.delete(sessionId);
+            this.restoringSessions.delete(sessionId);
+            this.bufferedRestoreData.delete(sessionId);
             this.emit('sessionDestroyed', session);
         }
     }

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

@@ -3,8 +3,9 @@ import { Either } from 'effect';
 import { SessionManager } from './sessionManager.js';
 import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
-import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, STATE_MINIMUM_DURATION_MS, } from '../constants/statePersistence.js';
 import { IDLE_DEBOUNCE_MS } from './stateDetector/claude.js';
+/** Must match `STATE_CHECK_INTERVAL_MS` in sessionManager.ts */
+const STATE_CHECK_INTERVAL_MS = 100;
 vi.mock('./bunTerminal.js', () => ({
     spawn: vi.fn(function () {
         return null;
@@ -41,7 +42,7 @@ vi.mock('./config/configReader.js', () => ({
         setAutoApprovalEnabled: vi.fn(),
     },
 }));
-describe('SessionManager - State Persistence', () => {
+describe('SessionManager - state detection', () => {
     let sessionManager;
     let mockPtyInstances;
     let eventEmitters;
@@ -50,7 +51,6 @@ describe('SessionManager - State Persistence', () => {
         sessionManager = new SessionManager();
         mockPtyInstances = new Map();
         eventEmitters = new Map();
-        // Create mock PTY process factory
         spawn.mockImplementation((command, args, options) => {
             const path = options.cwd;
             const eventEmitter = new EventEmitter();
@@ -79,211 +79,35 @@ describe('SessionManager - State Persistence', () => {
         vi.useRealTimers();
         vi.clearAllMocks();
     });
-    it('should not change state immediately when detected state changes', async () => {
+    it('transitions busy to idle after idle debounce and the next poll', async () => {
         const { Effect } = await import('effect');
         const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
-        // Initial state should be busy
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        // Simulate output that would trigger idle state
         eventEmitter.emit('data', 'Some output without busy indicators');
-        // Advance time past idle debounce so detector starts returning idle,
-        // but not enough for persistence to confirm
         await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
-        // State should still be busy, but pending state should be set
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
-        expect(session.stateMutex.getSnapshot().pendingStateStart).toBeDefined();
-    });
-    it('should change state after both persistence and minimum duration are met', async () => {
-        const { Effect } = await import('effect');
-        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
-        const eventEmitter = eventEmitters.get('/test/path');
-        const stateChangeHandler = vi.fn();
-        sessionManager.on('sessionStateChanged', stateChangeHandler);
-        // Initial state should be busy
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        // Simulate output that would trigger idle state
-        eventEmitter.emit('data', 'Some output without busy indicators');
-        // Advance time past idle debounce but not persistence+minimum
-        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        expect(stateChangeHandler).not.toHaveBeenCalled();
-        // Advance time past both persistence and minimum duration
-        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS);
-        // State should now be changed
         expect(session.stateMutex.getSnapshot().state).toBe('idle');
-        expect(session.stateMutex.getSnapshot().pendingState).toBeUndefined();
-        expect(session.stateMutex.getSnapshot().pendingStateStart).toBeUndefined();
-        expect(stateChangeHandler).toHaveBeenCalledWith(session);
     });
-    it('should cancel pending state if detected state changes again before persistence', async () => {
+    it('transitions busy to waiting_input on the next poll without idle debounce', async () => {
         const { Effect } = await import('effect');
         const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
-        // Initial state should be busy
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        // Simulate output that would trigger idle state
-        eventEmitter.emit('data', 'Some output without busy indicators');
-        // Advance time past idle debounce so detector starts returning idle
-        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
-        expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
-        // Simulate output that would trigger waiting_input state
         eventEmitter.emit('data', 'Do you want to continue?\n❯ 1. Yes');
-        // Advance time to trigger another check (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS);
-        // Pending state should now be waiting_input, not idle
-        expect(session.stateMutex.getSnapshot().state).toBe('busy'); // Still original state
-        expect(session.stateMutex.getSnapshot().pendingState).toBe('waiting_input');
-    });
-    it('should clear pending state if detected state returns to current state', async () => {
-        const { Effect } = await import('effect');
-        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
-        const eventEmitter = eventEmitters.get('/test/path');
-        // Initial state should be busy
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        // Simulate output that would trigger idle state
-        eventEmitter.emit('data', 'Some output without busy indicators');
-        // Advance time past idle debounce so detector starts returning idle
-        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
-        expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
-        expect(session.stateMutex.getSnapshot().pendingStateStart).toBeDefined();
-        // Simulate output that would trigger busy state again (back to original)
-        eventEmitter.emit('data', 'ESC to interrupt');
-        // Advance time to trigger another check (use async to process mutex updates)
         await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS);
-        // Pending state should be cleared
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        expect(session.stateMutex.getSnapshot().pendingState).toBeUndefined();
-        expect(session.stateMutex.getSnapshot().pendingStateStart).toBeUndefined();
+        expect(session.stateMutex.getSnapshot().state).toBe('waiting_input');
     });
-    it('should not confirm state changes that do not persist long enough', async () => {
-        const { Effect } = await import('effect');
-        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
-        const eventEmitter = eventEmitters.get('/test/path');
-        const stateChangeHandler = vi.fn();
-        sessionManager.on('sessionStateChanged', stateChangeHandler);
-        // Initial state should be busy
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        // Try to change to idle
-        eventEmitter.emit('data', 'Some idle output\n');
-        // Wait past idle debounce so detector returns idle, then one check
-        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
-        // Should have pending state but not confirmed
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
-        // Now change to a different state before idle persists
-        // Clear terminal first and add waiting prompt
-        eventEmitter.emit('data', '\x1b[2J\x1b[HDo you want to continue?\n❯ 1. Yes');
-        // Advance time to detect new state
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS);
-        // Pending state should have changed to waiting_input
-        expect(session.stateMutex.getSnapshot().state).toBe('busy'); // Still original state
-        expect(session.stateMutex.getSnapshot().pendingState).toBe('waiting_input');
-        // Since states kept changing before persisting, no state change should have been confirmed
-        expect(stateChangeHandler).not.toHaveBeenCalled();
-    });
-    it('should properly clean up pending state when session is destroyed', async () => {
-        const { Effect } = await import('effect');
-        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
-        const eventEmitter = eventEmitters.get('/test/path');
-        // Simulate output that would trigger idle state
-        eventEmitter.emit('data', 'Some output without busy indicators');
-        // Advance time past idle debounce so detector returns idle
-        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
-        expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
-        expect(session.stateMutex.getSnapshot().pendingStateStart).toBeDefined();
-        // Destroy the session
-        sessionManager.destroySession(session.id);
-        // Check that pending state is cleared
-        const remainingSessions = sessionManager.getSessionsForWorktree('/test/path');
-        expect(remainingSessions).toHaveLength(0);
-    });
-    it('should not transition state before minimum duration in current state has elapsed', async () => {
-        const { Effect } = await import('effect');
-        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
-        const eventEmitter = eventEmitters.get('/test/path');
-        const stateChangeHandler = vi.fn();
-        sessionManager.on('sessionStateChanged', stateChangeHandler);
-        // Initial state should be busy
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        // Simulate output that would trigger idle state
-        eventEmitter.emit('data', 'Some output without busy indicators');
-        // Advance past idle debounce but not past persistence + minimum duration
-        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS +
-            STATE_PERSISTENCE_DURATION_MS -
-            STATE_CHECK_INTERVAL_MS);
-        // State should still be busy because minimum duration hasn't elapsed
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        expect(stateChangeHandler).not.toHaveBeenCalled();
-    });
-    it('should transition state after both persistence and minimum duration are met', async () => {
-        const { Effect } = await import('effect');
-        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
-        const eventEmitter = eventEmitters.get('/test/path');
-        const stateChangeHandler = vi.fn();
-        sessionManager.on('sessionStateChanged', stateChangeHandler);
-        // Initial state should be busy
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        // Simulate output that would trigger idle state
-        eventEmitter.emit('data', 'Some output without busy indicators');
-        // Advance past idle debounce + persistence/minimum duration
-        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_MINIMUM_DURATION_MS + STATE_CHECK_INTERVAL_MS);
-        // State should now be idle since both durations are satisfied
-        expect(session.stateMutex.getSnapshot().state).toBe('idle');
-        expect(stateChangeHandler).toHaveBeenCalledWith(session);
-    });
-    it('should not transition during brief screen redraw even after long time in current state', async () => {
-        const { Effect } = await import('effect');
-        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
-        const eventEmitter = eventEmitters.get('/test/path');
-        const stateChangeHandler = vi.fn();
-        sessionManager.on('sessionStateChanged', stateChangeHandler);
-        // Initial state should be busy
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        // Keep busy state active for a long time (simulating normal operation)
-        // Each check re-detects "busy" and updates stateConfirmedAt
-        eventEmitter.emit('data', 'ESC to interrupt');
-        await vi.advanceTimersByTimeAsync(2000); // 2 seconds of confirmed busy
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        // Now simulate a brief screen redraw: busy indicators disappear temporarily
-        eventEmitter.emit('data', '\x1b[2J\x1b[H'); // Clear screen
-        // Idle debounce prevents the detector from returning idle for IDLE_DEBOUNCE_MS,
-        // so during a brief redraw (< 1500ms), no pending idle state is set.
-        // Advance a short time — still within the idle debounce window
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3); // 300ms
-        // State should still be busy — idle debounce hasn't elapsed
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        expect(stateChangeHandler).not.toHaveBeenCalled();
-        // Simulate busy indicators coming back (screen redraw complete)
-        eventEmitter.emit('data', 'ESC to interrupt');
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS);
-        // State should still be busy and pending should be cleared
-        expect(session.stateMutex.getSnapshot().state).toBe('busy');
-        expect(session.stateMutex.getSnapshot().pendingState).toBeUndefined();
-        expect(stateChangeHandler).not.toHaveBeenCalled();
-    });
-    it('should handle multiple sessions with independent state persistence', async () => {
+    it('handles multiple sessions independently', async () => {
         const { Effect } = await import('effect');
         const session1 = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path1'));
         const session2 = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path2'));
         const eventEmitter1 = eventEmitters.get('/test/path1');
         const eventEmitter2 = eventEmitters.get('/test/path2');
-        // Both should start as busy
         expect(session1.stateMutex.getSnapshot().state).toBe('busy');
         expect(session2.stateMutex.getSnapshot().state).toBe('busy');
-        // Simulate different outputs for each session
-        // Session 1 goes to idle
         eventEmitter1.emit('data', 'Idle output for session 1');
-        // Session 2 goes to waiting_input (no idle debounce for waiting_input)
         eventEmitter2.emit('data', 'Do you want to continue?\n❯ 1. Yes');
-        // Advance past idle debounce for session 1 + persistence/minimum for both
-        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_MINIMUM_DURATION_MS + STATE_CHECK_INTERVAL_MS);
-        // Both should now be in their new states
-        // Session 2 (waiting_input) transitions faster since it's not debounced
+        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
         expect(session1.stateMutex.getSnapshot().state).toBe('idle');
-        expect(session1.stateMutex.getSnapshot().pendingState).toBeUndefined();
         expect(session2.stateMutex.getSnapshot().state).toBe('waiting_input');
-        expect(session2.stateMutex.getSnapshot().pendingState).toBeUndefined();
     });
 });

package/dist/services/sessionManager.test.js

@@ -50,13 +50,27 @@ vi.mock('@xterm/addon-serialize', () => ({
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn(function () {
+            const normalBuffer = {
+                type: 'normal',
+                baseY: 0,
+                cursorY: 0,
+                cursorX: 0,
+                length: 0,
+                getLine: vi.fn(function () {
+                    return null;
+                }),
+            };
             return {
                 rows: 24,
                 cols: 80,
                 buffer: {
-                    active: {
-                        type: 'normal',
+                    active: normalBuffer,
+                    normal: normalBuffer,
+                    alternate: {
+                        type: 'alternate',
                         baseY: 0,
+                        cursorY: 0,
+                        cursorX: 0,
                         length: 0,
                         getLine: vi.fn(function () {
                             return null;
@@ -760,7 +774,7 @@ describe('SessionManager', () => {
         });
     });
     describe('session restore snapshots', () => {
-        it('should emit serialized terminal output when activating a session', async () => {
+        it('should emit a bounded normal-buffer restore snapshot and restore the cursor position', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
@@ -768,14 +782,44 @@ describe('SessionManager', () => {
             });
             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[31mrestored\u001b[0m');
             const restoreHandler = vi.fn();
             sessionManager.on('sessionRestore', restoreHandler);
             sessionManager.setSessionActive(session.id, true);
+            expect(serializeMock).toHaveBeenCalledWith({
+                range: {
+                    start: 120,
+                    end: 299,
+                },
+                excludeAltBuffer: true,
+            });
+            expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mrestored\u001b[0m\u001b[8;12H');
+        });
+        it('should keep viewport-only restore behavior for alternate screen 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.terminal.buffer.active = session.terminal.buffer.alternate;
+            const serializeMock = vi
+                .spyOn(session.serializer, 'serialize')
+                .mockReturnValue('\u001b[31malt\u001b[0m');
+            const restoreHandler = vi.fn();
+            sessionManager.on('sessionRestore', restoreHandler);
+            sessionManager.setSessionActive(session.id, true);
             expect(serializeMock).toHaveBeenCalledWith({ scrollback: 0 });
-            expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mrestored\u001b[0m');
+            expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31malt\u001b[0m');
         });
         it('should skip restore event when serialized output is empty', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
@@ -791,6 +835,43 @@ describe('SessionManager', () => {
             sessionManager.setSessionActive(session.id, true);
             expect(restoreHandler).not.toHaveBeenCalled();
         });
+        it('should reset restore scrollback baseline after a clear-screen sequence', 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 = 17;
+            mockPty.emit('data', '\x1b[2J\x1b[Hfresh');
+            expect(session.restoreScrollbackBaseLine).toBe(17);
+        });
+        it('should flush live session data after the restore snapshot completes', 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.length = 1;
+            vi.spyOn(session.serializer, 'serialize').mockReturnValue('restored');
+            const eventOrder = [];
+            sessionManager.on('sessionRestore', restoredSession => {
+                if (restoredSession.id === session.id) {
+                    eventOrder.push('restore');
+                    mockPty.emit('data', 'live-output');
+                }
+            });
+            sessionManager.on('sessionData', activeSession => {
+                if (activeSession.id === session.id) {
+                    eventOrder.push('data');
+                }
+            });
+            sessionManager.setSessionActive(session.id, true);
+            expect(eventOrder).toEqual(['restore', 'data']);
+        });
     });
     describe('static methods', () => {
         describe('getSessionCounts', () => {

package/dist/services/stateDetector/claude.js

@@ -1,8 +1,11 @@
 import { BaseStateDetector } from './base.js';
-// Spinner characters used by Claude Code during active processing
-const SPINNER_CHARS = '✱✲✳✴✵✶✷✸✹✺✻✼✽✾✿❀❁❂❃❇❈❉❊❋✢✣✤✥✦✧✨⊛⊕⊙◉◎◍⁂⁕※⍟☼★☆';
-// Matches spinner activity labels like "✽ Tempering…" or "✳ Simplifying recompute_tangents…"
+// Spinner / activity-prefix characters (line must still match SPINNER_ACTIVITY_PATTERN: …ing + …)
+// Includes: ornament spinners; · / • / ∙ / ⋅ bullets; ⏺ (record); ▸▹ triangles; ○● circles
+const SPINNER_CHARS = '✱✲✳✴✵✶✷✸✹✺✻✼✽✾✿❀❁❂❃❇❈❉❊❋✢✣✤✥✦✧✨⊛⊕⊙◉◎◍⁂⁕※⍟☼★☆·•⏺▸▹∙⋅○●';
+// Matches spinner activity labels like "✽ Tempering…", "✳ Simplifying…", or "· Misting…"
 const SPINNER_ACTIVITY_PATTERN = new RegExp(`^[${SPINNER_CHARS}] \\S+ing.*\u2026`, 'm');
+// Session stats above the prompt, e.g. "(9m 21s · ↓ 13.7k tokens)" — requires parens, a digit, and "tokens"
+const TOKEN_STATS_LINE_PATTERN = /\([^)]*\d[^)]*tokens\s*\)/i;
 const BUSY_LOOKBACK_LINES = 5;
 // Workaround: Claude Code sometimes appears idle in terminal output while
 // still actively processing (busy). To mitigate false idle transitions,
@@ -122,6 +125,10 @@ export class ClaudeStateDetector extends BaseStateDetector {
         if (SPINNER_ACTIVITY_PATTERN.test(abovePromptBox)) {
             return 'busy';
         }
+        // Usage/time + token count line (often shown above the prompt while a turn is active)
+        if (TOKEN_STATS_LINE_PATTERN.test(abovePromptBox)) {
+            return 'busy';
+        }
         // Otherwise idle (debounced)
         return this.debounceIdle(terminal, currentState);
     }

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

@@ -330,6 +330,43 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('busy');
         });
+        it('should detect busy for middle-dot activity label "· …ing…" (e.g. · Misting…)', () => {
+            terminal = createMockTerminal([
+                '· Misting…',
+                '   ⎿  Tip: Run /terminal-setup to enable convenient terminal integration',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
+            ]);
+            expect(detector.detectState(terminal, 'idle')).toBe('busy');
+        });
+        it('should detect busy when token stats line is above prompt box without interrupt or spinner', () => {
+            terminal = createMockTerminal([
+                '(9m 21s · ↓ 13.7k tokens)',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
+            ]);
+            expect(detector.detectState(terminal, 'idle')).toBe('busy');
+        });
+        it('should detect busy for token stats line with varied spacing and casing', () => {
+            terminal = createMockTerminal([
+                '  ( 1m · 500 TOKENS )  ',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
+            ]);
+            expect(detector.detectState(terminal, 'idle')).toBe('busy');
+        });
+        it('should not treat parenthetical text with "tokens" but no digit as busy', () => {
+            terminal = createMockTerminal([
+                '(see tokens in docs)',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
+            ]);
+            expect(detectStateAfterDebounce(detector, terminal, 'idle')).toBe('idle');
+        });
         it('should detect busy with various spinner characters', () => {
             const spinnerChars = [
                 '✱',

package/dist/types/index.d.ts

@@ -30,6 +30,7 @@ export interface Session {
     isActive: boolean;
     terminal: Terminal;
     serializer: SerializeAddon;
+    restoreScrollbackBaseLine: number;
     stateCheckInterval: NodeJS.Timeout | undefined;
     isPrimaryCommand: boolean;
     presetName: string | undefined;
@@ -38,7 +39,7 @@ export interface Session {
     /**
      * Mutex-protected session state data.
      * Access via stateMutex.runExclusive() or stateMutex.update() to ensure thread-safe operations.
-     * Contains: state, pendingState, pendingStateStart, autoApprovalFailed, autoApprovalReason, autoApprovalAbortController
+     * Contains: state, autoApprovalFailed, autoApprovalReason, autoApprovalAbortController, backgroundTaskCount, teamMemberCount
      */
     stateMutex: Mutex<SessionStateData>;
     /**

package/dist/utils/hookExecutor.test.js

@@ -383,6 +383,7 @@ describe('hookExecutor Integration Tests', () => {
                 process: {},
                 terminal: {},
                 serializer: {},
+                restoreScrollbackBaseLine: 0,
                 output: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
@@ -442,6 +443,7 @@ describe('hookExecutor Integration Tests', () => {
                 process: {},
                 terminal: {},
                 serializer: {},
+                restoreScrollbackBaseLine: 0,
                 output: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
@@ -499,6 +501,7 @@ describe('hookExecutor Integration Tests', () => {
                 process: {},
                 terminal: {},
                 serializer: {},
+                restoreScrollbackBaseLine: 0,
                 output: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
@@ -558,6 +561,7 @@ describe('hookExecutor Integration Tests', () => {
                 process: {},
                 terminal: {},
                 serializer: {},
+                restoreScrollbackBaseLine: 0,
                 output: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,

package/dist/utils/mutex.d.ts

@@ -42,9 +42,6 @@ export declare class Mutex<T> {
  */
 export interface SessionStateData {
     state: import('../types/index.js').SessionState;
-    pendingState: import('../types/index.js').SessionState | undefined;
-    pendingStateStart: number | undefined;
-    stateConfirmedAt: number;
     autoApprovalFailed: boolean;
     autoApprovalReason: string | undefined;
     autoApprovalAbortController: AbortController | undefined;

package/dist/utils/mutex.js

@@ -80,9 +80,6 @@ export class Mutex {
 export function createInitialSessionStateData() {
     return {
         state: 'busy',
-        pendingState: undefined,
-        pendingStateStart: undefined,
-        stateConfirmedAt: Date.now(),
         autoApprovalFailed: false,
         autoApprovalReason: undefined,
         autoApprovalAbortController: undefined,

package/dist/utils/worktreeUtils.test.js

@@ -133,6 +133,7 @@ describe('prepareSessionItems', () => {
         isActive: true,
         terminal: {},
         serializer: {},
+        restoreScrollbackBaseLine: 0,
         stateCheckInterval: undefined,
         isPrimaryCommand: true,
         presetName: undefined,

package/package.json

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

package/dist/constants/statePersistence.d.ts

@@ -1,3 +0,0 @@
-export declare const STATE_PERSISTENCE_DURATION_MS = 1000;
-export declare const STATE_CHECK_INTERVAL_MS = 100;
-export declare const STATE_MINIMUM_DURATION_MS = 1000;

package/dist/constants/statePersistence.js

@@ -1,9 +0,0 @@
-// Duration in milliseconds that a detected state must persist before being confirmed.
-// A higher value prevents transient flicker (e.g., brief "idle" during terminal re-renders)
-// at the cost of slightly slower state transitions.
-export const STATE_PERSISTENCE_DURATION_MS = 1000;
-// Check interval for state detection in milliseconds
-export const STATE_CHECK_INTERVAL_MS = 100;
-// Minimum duration in current state before allowing transition to a new state.
-// Prevents rapid back-and-forth flicker (e.g., busy → idle → busy).
-export const STATE_MINIMUM_DURATION_MS = 1000;