ccmanager 3.1.3 → 3.1.5

package/dist/components/Session.js

@@ -5,17 +5,18 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
     const { stdout } = useStdout();
     const [isExiting, setIsExiting] = useState(false);
     const deriveStatus = (currentSession) => {
+        const stateData = currentSession.stateMutex.getSnapshot();
         // Always prioritize showing the manual approval notice when verification failed
-        if (currentSession.autoApprovalFailed) {
-            const reason = currentSession.autoApprovalReason
-                ? ` Reason: ${currentSession.autoApprovalReason}.`
+        if (stateData.autoApprovalFailed) {
+            const reason = stateData.autoApprovalReason
+                ? ` Reason: ${stateData.autoApprovalReason}.`
                 : '';
             return {
                 message: `Auto-approval failed.${reason} Manual approval required—respond to the prompt.`,
                 variant: 'error',
             };
         }
-        if (currentSession.state === 'pending_auto_approval') {
+        if (stateData.state === 'pending_auto_approval') {
             return {
                 message: 'Auto-approval pending... verifying permissions (press any key to cancel)',
                 variant: 'pending',
@@ -192,7 +193,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
                 onReturnToMenu();
                 return;
             }
-            if (session.state === 'pending_auto_approval') {
+            if (session.stateMutex.getSnapshot().state === 'pending_auto_approval') {
                 sessionManager.cancelAutoApproval(session.worktreePath, 'User input received during auto-approval');
             }
             // Pass all other input directly to the PTY

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

@@ -4,7 +4,11 @@ import { spawn } from 'node-pty';
 import { STATE_CHECK_INTERVAL_MS, STATE_PERSISTENCE_DURATION_MS, } from '../constants/statePersistence.js';
 import { Effect } from 'effect';
 const detectStateMock = vi.fn();
-const verifyNeedsPermissionMock = vi.fn(() => Effect.succeed({ needsPermission: false }));
+// Create a deferred promise pattern for controllable mock
+let verifyResolve = null;
+const verifyNeedsPermissionMock = vi.fn(() => Effect.promise(() => new Promise(resolve => {
+    verifyResolve = resolve;
+})));
 vi.mock('node-pty', () => ({
     spawn: vi.fn(),
 }));
@@ -70,6 +74,7 @@ describe('SessionManager - Auto Approval Recovery', () => {
         vi.useFakeTimers();
         detectStateMock.mockReset();
         verifyNeedsPermissionMock.mockClear();
+        verifyResolve = null;
         mockPtyInstances = new Map();
         eventEmitters = new Map();
         spawn.mockImplementation((_command, _args, options) => {
@@ -124,37 +129,81 @@ describe('SessionManager - Auto Approval Recovery', () => {
     it('re-enables auto approval after leaving waiting_input', async () => {
         const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         // Simulate a prior auto-approval failure
-        session.autoApprovalFailed = true;
-        // First waiting_input cycle (auto-approval suppressed)
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 3);
-        expect(session.state).toBe('waiting_input');
-        expect(session.autoApprovalFailed).toBe(true);
-        // Transition back to busy should reset the failure flag
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 3);
-        expect(session.state).toBe('busy');
-        expect(session.autoApprovalFailed).toBe(false);
-        // Next waiting_input should trigger pending_auto_approval
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 3 + STATE_PERSISTENCE_DURATION_MS);
-        expect(session.state).toBe('pending_auto_approval');
-        await Promise.resolve(); // allow handleAutoApproval promise to resolve
+        await session.stateMutex.update(data => ({
+            ...data,
+            autoApprovalFailed: true,
+        }));
+        // First waiting_input cycle (auto-approval suppressed) (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3);
+        expect(session.stateMutex.getSnapshot().state).toBe('waiting_input');
+        expect(session.stateMutex.getSnapshot().autoApprovalFailed).toBe(true);
+        // Transition back to busy should reset the failure flag (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3);
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        expect(session.stateMutex.getSnapshot().autoApprovalFailed).toBe(false);
+        // Next waiting_input should trigger pending_auto_approval (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3 + STATE_PERSISTENCE_DURATION_MS);
+        // State should now be pending_auto_approval (waiting for verification)
+        expect(session.stateMutex.getSnapshot().state).toBe('pending_auto_approval');
         expect(verifyNeedsPermissionMock).toHaveBeenCalled();
+        // Resolve the verification (needsPermission: false means auto-approve)
+        expect(verifyResolve).not.toBeNull();
+        verifyResolve({ needsPermission: false });
+        await Promise.resolve(); // allow handleAutoApproval promise to resolve
     });
     it('cancels auto approval when user input is detected', async () => {
         const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const abortController = new AbortController();
-        session.state = 'pending_auto_approval';
-        session.autoApprovalAbortController = abortController;
-        session.pendingState = 'pending_auto_approval';
-        session.pendingStateStart = Date.now();
+        await session.stateMutex.update(data => ({
+            ...data,
+            state: 'pending_auto_approval',
+            autoApprovalAbortController: abortController,
+            pendingState: 'pending_auto_approval',
+            pendingStateStart: Date.now(),
+        }));
         const handler = vi.fn();
         sessionManager.on('sessionStateChanged', handler);
         sessionManager.cancelAutoApproval(session.worktreePath, 'User pressed a key');
+        // Wait for async mutex update to complete (use vi.waitFor for proper async handling)
+        await vi.waitFor(() => {
+            const stateData = session.stateMutex.getSnapshot();
+            expect(stateData.autoApprovalAbortController).toBeUndefined();
+        });
+        const stateData = session.stateMutex.getSnapshot();
         expect(abortController.signal.aborted).toBe(true);
-        expect(session.autoApprovalAbortController).toBeUndefined();
-        expect(session.autoApprovalFailed).toBe(true);
-        expect(session.state).toBe('waiting_input');
-        expect(session.pendingState).toBeUndefined();
+        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);
     });
+    it('forces state to busy after auto-approval to prevent endless loop', async () => {
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
+        const mockPty = mockPtyInstances.get('/test/path');
+        expect(mockPty).toBeDefined();
+        const handler = vi.fn();
+        sessionManager.on('sessionStateChanged', handler);
+        // Advance to pending_auto_approval state (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3 + STATE_PERSISTENCE_DURATION_MS);
+        // State should be pending_auto_approval (waiting for verification)
+        expect(session.stateMutex.getSnapshot().state).toBe('pending_auto_approval');
+        expect(verifyNeedsPermissionMock).toHaveBeenCalled();
+        // Resolve the verification (needsPermission: false means auto-approve)
+        expect(verifyResolve).not.toBeNull();
+        verifyResolve({ needsPermission: false });
+        // Wait for handleAutoApproval promise chain to fully resolve
+        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
+        const lastCall = handler.mock.calls[handler.mock.calls.length - 1];
+        expect(lastCall).toBeDefined();
+        expect(lastCall[0].stateMutex.getSnapshot().state).toBe('busy');
+        sessionManager.off('sessionStateChanged', handler);
+    });
 });

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

@@ -110,7 +110,7 @@ describe('SessionManager Effect-based Operations', () => {
             const session = await Effect.runPromise(effect);
             expect(session).toBeDefined();
             expect(session.worktreePath).toBe('/test/worktree');
-            expect(session.state).toBe('busy');
+            expect(session.stateMutex.getSnapshot().state).toBe('busy');
         });
         it('should return Effect that fails with ConfigError when preset not found', async () => {
             // Setup mocks - both return null/undefined

package/dist/services/sessionManager.js

@@ -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,74 +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
+                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() {
@@ -168,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(),
@@ -179,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);
@@ -350,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);
@@ -389,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);
@@ -404,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
@@ -412,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);
@@ -443,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
@@ -644,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

@@ -83,15 +83,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 +100,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 +120,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 +162,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 +187,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 +204,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();
     });
 });

package/dist/services/sessionManager.test.js

@@ -705,13 +705,20 @@ describe('SessionManager', () => {
     });
     describe('static methods', () => {
         describe('getSessionCounts', () => {
+            // Helper to create mock session with stateMutex
+            const createMockSession = (id, state) => ({
+                id,
+                stateMutex: {
+                    getSnapshot: () => ({ state }),
+                },
+            });
             it('should count sessions by state', () => {
                 const sessions = [
-                    { id: '1', state: 'idle' },
-                    { id: '2', state: 'busy' },
-                    { id: '3', state: 'busy' },
-                    { id: '4', state: 'waiting_input' },
-                    { id: '5', state: 'idle' },
+                    createMockSession('1', 'idle'),
+                    createMockSession('2', 'busy'),
+                    createMockSession('3', 'busy'),
+                    createMockSession('4', 'waiting_input'),
+                    createMockSession('5', 'idle'),
                 ];
                 const counts = SessionManager.getSessionCounts(sessions);
                 expect(counts.idle).toBe(2);
@@ -728,9 +735,9 @@ describe('SessionManager', () => {
             });
             it('should handle sessions with single state', () => {
                 const sessions = [
-                    { id: '1', state: 'busy' },
-                    { id: '2', state: 'busy' },
-                    { id: '3', state: 'busy' },
+                    createMockSession('1', 'busy'),
+                    createMockSession('2', 'busy'),
+                    createMockSession('3', 'busy'),
                 ];
                 const counts = SessionManager.getSessionCounts(sessions);
                 expect(counts.idle).toBe(0);

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
 import { IPty } from 'node-pty';
 import type pkg from '@xterm/headless';
 import { GitStatus } from '../utils/gitStatus.js';
+import { Mutex, SessionStateData } from '../utils/mutex.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input' | 'pending_auto_approval';
 export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline';
@@ -16,7 +17,6 @@ export interface Session {
     id: string;
     worktreePath: string;
     process: IPty;
-    state: SessionState;
     output: string[];
     outputHistory: Buffer[];
     lastActivity: Date;
@@ -27,11 +27,12 @@ export interface Session {
     commandConfig: CommandConfig | undefined;
     detectionStrategy: StateDetectionStrategy | undefined;
     devcontainerConfig: DevcontainerConfig | undefined;
-    pendingState: SessionState | undefined;
-    pendingStateStart: number | undefined;
-    autoApprovalFailed: boolean;
-    autoApprovalReason?: string;
-    autoApprovalAbortController?: AbortController;
+    /**
+     * Mutex-protected session state data.
+     * Access via stateMutex.runExclusive() or stateMutex.update() to ensure thread-safe operations.
+     * Contains: state, pendingState, pendingStateStart, autoApprovalFailed, autoApprovalReason, autoApprovalAbortController
+     */
+    stateMutex: Mutex<SessionStateData>;
 }
 export interface AutoApprovalResponse {
     needsPermission: boolean;

package/dist/utils/hookExecutor.test.js

@@ -7,6 +7,7 @@ import { join } from 'path';
 import { configurationManager } from '../services/configurationManager.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { GitError } from '../types/errors.js';
+import { Mutex, createInitialSessionStateData } from './mutex.js';
 // Mock the configurationManager
 vi.mock('../services/configurationManager.js', () => ({
     configurationManager: {
@@ -262,17 +263,14 @@ describe('hookExecutor Integration Tests', () => {
                 terminal: {},
                 output: [],
                 outputHistory: [],
-                state: 'idle',
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
-                pendingState: undefined,
-                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
-                autoApprovalFailed: false,
+                stateMutex: new Mutex(createInitialSessionStateData()),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(() => ({
@@ -317,17 +315,14 @@ describe('hookExecutor Integration Tests', () => {
                 terminal: {},
                 output: [],
                 outputHistory: [],
-                state: 'idle',
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
-                pendingState: undefined,
-                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
-                autoApprovalFailed: false,
+                stateMutex: new Mutex(createInitialSessionStateData()),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(() => ({
@@ -370,17 +365,14 @@ describe('hookExecutor Integration Tests', () => {
                 terminal: {},
                 output: [],
                 outputHistory: [],
-                state: 'idle',
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
-                pendingState: undefined,
-                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
-                autoApprovalFailed: false,
+                stateMutex: new Mutex(createInitialSessionStateData()),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(() => ({
@@ -425,17 +417,14 @@ describe('hookExecutor Integration Tests', () => {
                 terminal: {},
                 output: [],
                 outputHistory: [],
-                state: 'idle',
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
-                pendingState: undefined,
-                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
-                autoApprovalFailed: false,
+                stateMutex: new Mutex(createInitialSessionStateData()),
             };
             // Mock WorktreeService to fail with GitError
             vi.mocked(WorktreeService).mockImplementation(() => ({

package/dist/utils/mutex.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A simple mutex implementation for protecting shared state.
+ * Provides exclusive access to wrapped data through async locking.
+ */
+export declare class Mutex<T> {
+    private data;
+    private locked;
+    private waitQueue;
+    constructor(initialData: T);
+    /**
+     * Acquire the lock. Returns a promise that resolves when the lock is acquired.
+     */
+    private acquire;
+    /**
+     * Release the lock, allowing the next waiter to proceed.
+     */
+    private release;
+    /**
+     * Run a function with exclusive access to the protected data.
+     * The lock is acquired before the function runs and released after it completes.
+     *
+     * @param fn - Function that receives the current data and returns updated data or a promise of updated data
+     * @returns Promise that resolves with the function's return value
+     */
+    runExclusive<R>(fn: (data: T) => R | Promise<R>): Promise<R>;
+    /**
+     * Run a function with exclusive access and update the protected data.
+     * The lock is acquired before the function runs and released after it completes.
+     *
+     * @param fn - Function that receives the current data and returns the updated data
+     */
+    update(fn: (data: T) => T | Promise<T>): Promise<void>;
+    /**
+     * Get a snapshot of the current data without acquiring the lock.
+     * Use with caution - this does not guarantee consistency.
+     * Prefer runExclusive for reads that need to be consistent with writes.
+     */
+    getSnapshot(): T;
+}
+/**
+ * Interface for the session state data protected by mutex.
+ */
+export interface SessionStateData {
+    state: import('../types/index.js').SessionState;
+    pendingState: import('../types/index.js').SessionState | undefined;
+    pendingStateStart: number | undefined;
+    autoApprovalFailed: boolean;
+    autoApprovalReason: string | undefined;
+    autoApprovalAbortController: AbortController | undefined;
+}
+/**
+ * Create initial session state data with default values.
+ */
+export declare function createInitialSessionStateData(): SessionStateData;

package/dist/utils/mutex.js

@@ -0,0 +1,104 @@
+/**
+ * A simple mutex implementation for protecting shared state.
+ * Provides exclusive access to wrapped data through async locking.
+ */
+export class Mutex {
+    constructor(initialData) {
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "locked", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "waitQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.data = initialData;
+    }
+    /**
+     * Acquire the lock. Returns a promise that resolves when the lock is acquired.
+     */
+    async acquire() {
+        if (!this.locked) {
+            this.locked = true;
+            return;
+        }
+        return new Promise(resolve => {
+            this.waitQueue.push(resolve);
+        });
+    }
+    /**
+     * Release the lock, allowing the next waiter to proceed.
+     */
+    release() {
+        const next = this.waitQueue.shift();
+        if (next) {
+            next();
+        }
+        else {
+            this.locked = false;
+        }
+    }
+    /**
+     * Run a function with exclusive access to the protected data.
+     * The lock is acquired before the function runs and released after it completes.
+     *
+     * @param fn - Function that receives the current data and returns updated data or a promise of updated data
+     * @returns Promise that resolves with the function's return value
+     */
+    async runExclusive(fn) {
+        await this.acquire();
+        try {
+            const result = await fn(this.data);
+            return result;
+        }
+        finally {
+            this.release();
+        }
+    }
+    /**
+     * Run a function with exclusive access and update the protected data.
+     * The lock is acquired before the function runs and released after it completes.
+     *
+     * @param fn - Function that receives the current data and returns the updated data
+     */
+    async update(fn) {
+        await this.acquire();
+        try {
+            this.data = await fn(this.data);
+        }
+        finally {
+            this.release();
+        }
+    }
+    /**
+     * Get a snapshot of the current data without acquiring the lock.
+     * Use with caution - this does not guarantee consistency.
+     * Prefer runExclusive for reads that need to be consistent with writes.
+     */
+    getSnapshot() {
+        return this.data;
+    }
+}
+/**
+ * Create initial session state data with default values.
+ */
+export function createInitialSessionStateData() {
+    return {
+        state: 'busy',
+        pendingState: undefined,
+        pendingStateStart: undefined,
+        autoApprovalFailed: false,
+        autoApprovalReason: undefined,
+        autoApprovalAbortController: undefined,
+    };
+}

package/dist/utils/worktreeUtils.js

@@ -71,7 +71,9 @@ export function extractBranchParts(branchName) {
 export function prepareWorktreeItems(worktrees, sessions) {
     return worktrees.map(wt => {
         const session = sessions.find(s => s.worktreePath === wt.path);
-        const status = session ? ` [${getStatusDisplay(session.state)}]` : '';
+        const status = session
+            ? ` [${getStatusDisplay(session.stateMutex.getSnapshot().state)}]`
+            : '';
         const fullBranchName = wt.branch
             ? wt.branch.replace('refs/heads/', '')
             : 'detached';

package/dist/utils/worktreeUtils.test.js

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { generateWorktreeDirectory, extractBranchParts, truncateString, prepareWorktreeItems, calculateColumnPositions, assembleWorktreeLabel, } from './worktreeUtils.js';
 import { execSync } from 'child_process';
+import { Mutex, createInitialSessionStateData } from './mutex.js';
 // Mock child_process module
 vi.mock('child_process');
 describe('generateWorktreeDirectory', () => {
@@ -121,7 +122,6 @@ describe('prepareWorktreeItems', () => {
     const mockSession = {
         id: 'test-session',
         worktreePath: '/path/to/worktree',
-        state: 'idle',
         process: {},
         output: [],
         outputHistory: [],
@@ -133,9 +133,10 @@ describe('prepareWorktreeItems', () => {
         commandConfig: undefined,
         detectionStrategy: 'claude',
         devcontainerConfig: undefined,
-        pendingState: undefined,
-        pendingStateStart: undefined,
-        autoApprovalFailed: false,
+        stateMutex: new Mutex({
+            ...createInitialSessionStateData(),
+            state: 'idle',
+        }),
     };
     it('should prepare basic worktree without git status', () => {
         const items = prepareWorktreeItems([mockWorktree], []);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.1.3",
+	"version": "3.1.5",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",