ccmanager 3.1.4 → 3.2.1

package/dist/services/sessionManager.js

@@ -1,4 +1,4 @@
-import { spawn } from 'node-pty';
+import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
 import pkg from '@xterm/headless';
 import { exec } from 'child_process';
@@ -11,6 +11,7 @@ import { Effect } from 'effect';
 import { ProcessError, ConfigError } from '../types/errors.js';
 import { autoApprovalVerifier } from './autoApprovalVerifier.js';
 import { logger } from '../utils/logger.js';
+import { Mutex, createInitialSessionStateData } from '../utils/mutex.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
 const TERMINAL_CONTENT_MAX_LINES = 300;
@@ -29,11 +30,12 @@ export class SessionManager extends EventEmitter {
         // Create a detector based on the session's detection strategy
         const strategy = session.detectionStrategy || 'claude';
         const detector = createStateDetector(strategy);
-        const detectedState = detector.detectState(session.terminal, session.state);
+        const stateData = session.stateMutex.getSnapshot();
+        const detectedState = detector.detectState(session.terminal, stateData.state);
         // If auto-approval is enabled and state is waiting_input, convert to pending_auto_approval
         if (detectedState === 'waiting_input' &&
             configurationManager.isAutoApprovalEnabled() &&
-            !session.autoApprovalFailed) {
+            !stateData.autoApprovalFailed) {
             return 'pending_auto_approval';
         }
         return detectedState;
@@ -58,80 +60,101 @@ export class SessionManager extends EventEmitter {
         // Cancel any existing verification before starting a new one
         this.cancelAutoApprovalVerification(session, 'Restarting verification for pending auto-approval state');
         const abortController = new AbortController();
-        session.autoApprovalAbortController = abortController;
-        session.autoApprovalReason = undefined;
+        void session.stateMutex.update(data => ({
+            ...data,
+            autoApprovalAbortController: abortController,
+            autoApprovalReason: undefined,
+        }));
         // Get terminal content for verification
         const terminalContent = this.getTerminalContent(session);
         // Verify if permission is needed
         void Effect.runPromise(autoApprovalVerifier.verifyNeedsPermission(terminalContent, {
             signal: abortController.signal,
         }))
-            .then(autoApprovalResult => {
+            .then(async (autoApprovalResult) => {
             if (abortController.signal.aborted) {
                 logger.debug(`[${session.id}] Auto-approval verification aborted before completion`);
                 return;
             }
             // If state already moved away, skip handling
-            if (session.state !== 'pending_auto_approval') {
-                logger.debug(`[${session.id}] Skipping auto-approval handling; current state is ${session.state}`);
+            const currentState = session.stateMutex.getSnapshot().state;
+            if (currentState !== 'pending_auto_approval') {
+                logger.debug(`[${session.id}] Skipping auto-approval handling; current state is ${currentState}`);
                 return;
             }
             if (autoApprovalResult.needsPermission) {
                 // Change state to waiting_input to ask for user permission
                 logger.info(`[${session.id}] Auto-approval verification determined user permission needed`);
-                session.state = 'waiting_input';
-                session.autoApprovalFailed = true;
-                session.autoApprovalReason = autoApprovalResult.reason;
-                session.pendingState = undefined;
-                session.pendingStateStart = undefined;
+                await session.stateMutex.update(data => ({
+                    ...data,
+                    state: 'waiting_input',
+                    autoApprovalFailed: true,
+                    autoApprovalReason: autoApprovalResult.reason,
+                    pendingState: undefined,
+                    pendingStateStart: undefined,
+                }));
                 this.emit('sessionStateChanged', session);
             }
             else {
                 // Auto-approve by simulating Enter key press
                 logger.info(`[${session.id}] Auto-approval granted, simulating user permission`);
-                session.autoApprovalReason = undefined;
                 session.process.write('\r');
                 // Force state to busy to prevent endless auto-approval
                 // when the state detection still sees pending_auto_approval
-                session.state = 'busy';
-                session.pendingState = undefined;
-                session.pendingStateStart = undefined;
+                await session.stateMutex.update(data => ({
+                    ...data,
+                    state: 'busy',
+                    autoApprovalReason: undefined,
+                    pendingState: undefined,
+                    pendingStateStart: undefined,
+                }));
                 this.emit('sessionStateChanged', session);
             }
         })
-            .catch((error) => {
+            .catch(async (error) => {
             if (abortController.signal.aborted) {
                 logger.debug(`[${session.id}] Auto-approval verification aborted (${error?.message ?? 'aborted'})`);
                 return;
             }
             // On failure, fall back to requiring explicit permission
             logger.error(`[${session.id}] Auto-approval verification failed, requiring user permission`, error);
-            if (session.state === 'pending_auto_approval') {
-                session.state = 'waiting_input';
-                session.autoApprovalFailed = true;
-                session.autoApprovalReason =
-                    error?.message ??
-                        'Auto-approval verification failed';
-                session.pendingState = undefined;
-                session.pendingStateStart = undefined;
+            const currentState = session.stateMutex.getSnapshot().state;
+            if (currentState === 'pending_auto_approval') {
+                await session.stateMutex.update(data => ({
+                    ...data,
+                    state: 'waiting_input',
+                    autoApprovalFailed: true,
+                    autoApprovalReason: error?.message ??
+                        'Auto-approval verification failed',
+                    pendingState: undefined,
+                    pendingStateStart: undefined,
+                }));
                 this.emit('sessionStateChanged', session);
             }
         })
-            .finally(() => {
-            if (session.autoApprovalAbortController === abortController) {
-                session.autoApprovalAbortController = undefined;
+            .finally(async () => {
+            const currentController = session.stateMutex.getSnapshot().autoApprovalAbortController;
+            if (currentController === abortController) {
+                await session.stateMutex.update(data => ({
+                    ...data,
+                    autoApprovalAbortController: undefined,
+                }));
             }
         });
     }
     cancelAutoApprovalVerification(session, reason) {
-        const controller = session.autoApprovalAbortController;
+        const stateData = session.stateMutex.getSnapshot();
+        const controller = stateData.autoApprovalAbortController;
         if (!controller) {
             return;
         }
         if (!controller.signal.aborted) {
             controller.abort();
         }
-        session.autoApprovalAbortController = undefined;
+        void session.stateMutex.update(data => ({
+            ...data,
+            autoApprovalAbortController: undefined,
+        }));
         logger.info(`[${session.id}] Cancelled auto-approval verification: ${reason}`);
     }
     constructor() {
@@ -174,7 +197,6 @@ export class SessionManager extends EventEmitter {
             id,
             worktreePath,
             process: ptyProcess,
-            state: 'busy', // Session starts as busy when created
             output: [],
             outputHistory: [],
             lastActivity: new Date(),
@@ -185,11 +207,7 @@ export class SessionManager extends EventEmitter {
             commandConfig,
             detectionStrategy: options.detectionStrategy ?? 'claude',
             devcontainerConfig: options.devcontainerConfig ?? undefined,
-            pendingState: undefined,
-            pendingStateStart: undefined,
-            autoApprovalFailed: false,
-            autoApprovalReason: undefined,
-            autoApprovalAbortController: undefined,
+            stateMutex: new Mutex(createInitialSessionStateData()),
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -356,37 +374,47 @@ export class SessionManager extends EventEmitter {
         this.setupDataHandler(session);
         // Set up interval-based state detection with persistence
         session.stateCheckInterval = setInterval(() => {
-            const oldState = session.state;
+            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 (session.pendingState !== detectedState) {
-                    session.pendingState = detectedState;
-                    session.pendingStateStart = now;
+                if (stateData.pendingState !== detectedState) {
+                    void session.stateMutex.update(data => ({
+                        ...data,
+                        pendingState: detectedState,
+                        pendingStateStart: now,
+                    }));
                 }
-                else if (session.pendingState !== undefined &&
-                    session.pendingStateStart !== undefined) {
+                else if (stateData.pendingState !== undefined &&
+                    stateData.pendingStateStart !== undefined) {
                     // Check if the pending state has persisted long enough
-                    const duration = now - session.pendingStateStart;
+                    const duration = now - stateData.pendingStateStart;
                     if (duration >= STATE_PERSISTENCE_DURATION_MS) {
                         // Confirm the state change
-                        session.state = detectedState;
-                        session.pendingState = undefined;
-                        session.pendingStateStart = undefined;
-                        if (session.autoApprovalAbortController &&
+                        void session.stateMutex.update(data => {
+                            const newData = {
+                                ...data,
+                                state: detectedState,
+                                pendingState: undefined,
+                                pendingStateStart: undefined,
+                            };
+                            // If we previously blocked auto-approval and have moved out of a user prompt,
+                            // allow future auto-approval attempts.
+                            if (data.autoApprovalFailed &&
+                                detectedState !== 'waiting_input' &&
+                                detectedState !== 'pending_auto_approval') {
+                                newData.autoApprovalFailed = false;
+                                newData.autoApprovalReason = undefined;
+                            }
+                            return newData;
+                        });
+                        if (stateData.autoApprovalAbortController &&
                             detectedState !== 'pending_auto_approval') {
                             this.cancelAutoApprovalVerification(session, `state changed to ${detectedState}`);
                         }
-                        // If we previously blocked auto-approval and have moved out of a user prompt,
-                        // allow future auto-approval attempts.
-                        if (session.autoApprovalFailed &&
-                            detectedState !== 'waiting_input' &&
-                            detectedState !== 'pending_auto_approval') {
-                            session.autoApprovalFailed = false;
-                            session.autoApprovalReason = undefined;
-                        }
                         // Execute status hook asynchronously (non-blocking) using Effect
                         void Effect.runPromise(executeStatusHook(oldState, detectedState, session));
                         this.emit('sessionStateChanged', session);
@@ -395,14 +423,18 @@ export class SessionManager extends EventEmitter {
             }
             else {
                 // Detected state matches current state, clear any pending state
-                session.pendingState = undefined;
-                session.pendingStateStart = undefined;
+                void session.stateMutex.update(data => ({
+                    ...data,
+                    pendingState: undefined,
+                    pendingStateStart: undefined,
+                }));
             }
             // 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
             // but the previous verification completed (success, failure, timeout, or abort).
-            if (session.state === 'pending_auto_approval' &&
-                !session.autoApprovalAbortController) {
+            const currentStateData = session.stateMutex.getSnapshot();
+            if (currentStateData.state === 'pending_auto_approval' &&
+                !currentStateData.autoApprovalAbortController) {
                 this.handleAutoApproval(session);
             }
         }, STATE_CHECK_INTERVAL_MS);
@@ -410,7 +442,8 @@ export class SessionManager extends EventEmitter {
         this.setupExitHandler(session);
     }
     cleanupSession(session) {
-        if (session.autoApprovalAbortController) {
+        const stateData = session.stateMutex.getSnapshot();
+        if (stateData.autoApprovalAbortController) {
             this.cancelAutoApprovalVerification(session, 'Session cleanup');
         }
         // Clear the state check interval
@@ -418,11 +451,13 @@ export class SessionManager extends EventEmitter {
             clearInterval(session.stateCheckInterval);
             session.stateCheckInterval = undefined;
         }
-        // Clear any pending state
-        session.pendingState = undefined;
-        session.pendingStateStart = undefined;
-        // Update state to idle before destroying
-        session.state = 'idle';
+        // Clear any pending state and update state to idle before destroying
+        void session.stateMutex.update(data => ({
+            ...data,
+            state: 'idle',
+            pendingState: undefined,
+            pendingStateStart: undefined,
+        }));
         this.emit('sessionStateChanged', session);
         this.destroySession(session.worktreePath);
         this.emit('sessionExit', session);
@@ -449,24 +484,34 @@ export class SessionManager extends EventEmitter {
         if (!session) {
             return;
         }
-        if (session.state !== 'pending_auto_approval' &&
-            !session.autoApprovalAbortController) {
+        const stateData = session.stateMutex.getSnapshot();
+        if (stateData.state !== 'pending_auto_approval' &&
+            !stateData.autoApprovalAbortController) {
             return;
         }
         this.cancelAutoApprovalVerification(session, reason);
-        session.autoApprovalFailed = true;
-        session.autoApprovalReason = reason;
-        session.pendingState = undefined;
-        session.pendingStateStart = undefined;
-        if (session.state === 'pending_auto_approval') {
-            session.state = 'waiting_input';
+        void session.stateMutex.update(data => {
+            const newData = {
+                ...data,
+                autoApprovalFailed: true,
+                autoApprovalReason: reason,
+                pendingState: undefined,
+                pendingStateStart: undefined,
+            };
+            if (data.state === 'pending_auto_approval') {
+                newData.state = 'waiting_input';
+            }
+            return newData;
+        });
+        if (stateData.state === 'pending_auto_approval') {
             this.emit('sessionStateChanged', session);
         }
     }
     destroySession(worktreePath) {
         const session = this.sessions.get(worktreePath);
         if (session) {
-            if (session.autoApprovalAbortController) {
+            const stateData = session.stateMutex.getSnapshot();
+            if (stateData.autoApprovalAbortController) {
                 this.cancelAutoApprovalVerification(session, 'Session destroyed');
             }
             // Clear the state check interval
@@ -650,7 +695,8 @@ export class SessionManager extends EventEmitter {
             total: sessions.length,
         };
         sessions.forEach(session => {
-            switch (session.state) {
+            const stateData = session.stateMutex.getSnapshot();
+            switch (stateData.state) {
                 case 'idle':
                     counts.idle++;
                     break;

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

@@ -1,10 +1,12 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import { SessionManager } from './sessionManager.js';
-import { spawn } from 'node-pty';
+import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
 import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
-vi.mock('node-pty', () => ({
-    spawn: vi.fn(),
+vi.mock('./bunTerminal.js', () => ({
+    spawn: vi.fn(function () {
+        return null;
+    }),
 }));
 vi.mock('./configurationManager.js', () => ({
     configurationManager: {
@@ -83,15 +85,15 @@ describe('SessionManager - State Persistence', () => {
         const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
         // Initial state should be busy
-        expect(session.state).toBe('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 less than persistence duration
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        // Advance time less than persistence duration (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
         // State should still be busy, but pending state should be set
-        expect(session.state).toBe('busy');
-        expect(session.pendingState).toBe('idle');
-        expect(session.pendingStateStart).toBeDefined();
+        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 persistence duration is met', async () => {
         const { Effect } = await import('effect');
@@ -100,19 +102,19 @@ describe('SessionManager - State Persistence', () => {
         const stateChangeHandler = vi.fn();
         sessionManager.on('sessionStateChanged', stateChangeHandler);
         // Initial state should be busy
-        expect(session.state).toBe('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 less than persistence duration
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
-        expect(session.state).toBe('busy');
+        // Advance time less than persistence duration (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
         expect(stateChangeHandler).not.toHaveBeenCalled();
         // Advance time to exceed persistence duration
-        vi.advanceTimersByTime(STATE_PERSISTENCE_DURATION_MS);
+        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS);
         // State should now be changed
-        expect(session.state).toBe('idle');
-        expect(session.pendingState).toBeUndefined();
-        expect(session.pendingStateStart).toBeUndefined();
+        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 () => {
@@ -120,40 +122,40 @@ describe('SessionManager - State Persistence', () => {
         const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
         // Initial state should be busy
-        expect(session.state).toBe('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 less than persistence duration
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
-        expect(session.pendingState).toBe('idle');
+        // Advance time less than persistence duration (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
+        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
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS);
+        // 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.state).toBe('busy'); // Still original state
-        expect(session.pendingState).toBe('waiting_input');
+        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.state).toBe('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 less than persistence duration
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
-        expect(session.pendingState).toBe('idle');
-        expect(session.pendingStateStart).toBeDefined();
+        // Advance time less than persistence duration (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
+        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
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS);
+        // 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.state).toBe('busy');
-        expect(session.pendingState).toBeUndefined();
-        expect(session.pendingStateStart).toBeUndefined();
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        expect(session.stateMutex.getSnapshot().pendingState).toBeUndefined();
+        expect(session.stateMutex.getSnapshot().pendingStateStart).toBeUndefined();
     });
     it('should not confirm state changes that do not persist long enough', async () => {
         const { Effect } = await import('effect');
@@ -162,22 +164,22 @@ describe('SessionManager - State Persistence', () => {
         const stateChangeHandler = vi.fn();
         sessionManager.on('sessionStateChanged', stateChangeHandler);
         // Initial state should be busy
-        expect(session.state).toBe('busy');
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
         // Try to change to idle
         eventEmitter.emit('data', 'Some idle output\n');
-        // Wait for detection but not full persistence (less than 200ms)
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS); // 100ms
+        // Wait for detection but not full persistence (less than 200ms) (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS); // 100ms
         // Should have pending state but not confirmed
-        expect(session.state).toBe('busy');
-        expect(session.pendingState).toBe('idle');
+        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 but still less than persistence duration from first change
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS); // Another 100ms, total 200ms exactly at threshold
+        // Advance time to detect new state but still less than persistence duration from first change (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS); // Another 100ms, total 200ms exactly at threshold
         // Pending state should have changed to waiting_input
-        expect(session.state).toBe('busy'); // Still original state
-        expect(session.pendingState).toBe('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();
     });
@@ -187,10 +189,10 @@ describe('SessionManager - State Persistence', () => {
         const eventEmitter = eventEmitters.get('/test/path');
         // Simulate output that would trigger idle state
         eventEmitter.emit('data', 'Some output without busy indicators');
-        // Advance time less than persistence duration
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
-        expect(session.pendingState).toBe('idle');
-        expect(session.pendingStateStart).toBeDefined();
+        // Advance time less than persistence duration (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
+        expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
+        expect(session.stateMutex.getSnapshot().pendingStateStart).toBeDefined();
         // Destroy the session
         sessionManager.destroySession('/test/path');
         // Check that pending state is cleared
@@ -204,26 +206,26 @@ describe('SessionManager - State Persistence', () => {
         const eventEmitter1 = eventEmitters.get('/test/path1');
         const eventEmitter2 = eventEmitters.get('/test/path2');
         // Both should start as busy
-        expect(session1.state).toBe('busy');
-        expect(session2.state).toBe('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
         eventEmitter2.emit('data', 'Do you want to continue?\n❯ 1. Yes');
-        // Advance time to check but not confirm
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        // Advance time to check but not confirm (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
         // Both should have pending states but not changed yet
-        expect(session1.state).toBe('busy');
-        expect(session1.pendingState).toBe('idle');
-        expect(session2.state).toBe('busy');
-        expect(session2.pendingState).toBe('waiting_input');
-        // Advance time to confirm both
-        vi.advanceTimersByTime(STATE_PERSISTENCE_DURATION_MS);
+        expect(session1.stateMutex.getSnapshot().state).toBe('busy');
+        expect(session1.stateMutex.getSnapshot().pendingState).toBe('idle');
+        expect(session2.stateMutex.getSnapshot().state).toBe('busy');
+        expect(session2.stateMutex.getSnapshot().pendingState).toBe('waiting_input');
+        // Advance time to confirm both (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS);
         // Both should now be in their new states
-        expect(session1.state).toBe('idle');
-        expect(session1.pendingState).toBeUndefined();
-        expect(session2.state).toBe('waiting_input');
-        expect(session2.pendingState).toBeUndefined();
+        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();
     });
 });