ccmanager 2.2.0 → 2.2.2

package/README.md

@@ -1,13 +1,11 @@
-# CCManager - AI Code Assistant Session Manager
-
-CCManager is a TUI application for managing multiple AI coding assistant sessions (Claude Code, Gemini CLI) across Git worktrees and projects.
+# CCManager - AI Code Agent Session Manager
 
+[![Mentioned in Awesome Gemini CLI](https://awesome.re/mentioned-badge.svg)](https://github.com/Piebald-AI/awesome-gemini-cli)
 
+CCManager is a CLI application for managing multiple AI coding assistant sessions (Claude Code, Gemini CLI, Codex CLI) across Git worktrees and projects.
 
 https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 
-
-
 ## Features
 
 - Run multiple AI assistant sessions in parallel across different Git worktrees

package/dist/constants/statePersistence.d.ts

@@ -0,0 +1,2 @@
+export declare const STATE_PERSISTENCE_DURATION_MS = 200;
+export declare const STATE_CHECK_INTERVAL_MS = 100;

package/dist/constants/statePersistence.js

@@ -0,0 +1,4 @@
+// Duration in milliseconds that a detected state must persist before being confirmed
+export const STATE_PERSISTENCE_DURATION_MS = 200;
+// Check interval for state detection in milliseconds
+export const STATE_CHECK_INTERVAL_MS = 100;

package/dist/services/sessionManager.js

@@ -6,6 +6,7 @@ import { promisify } from 'util';
 import { configurationManager } from './configurationManager.js';
 import { executeStatusHook } from '../utils/hookExecutor.js';
 import { createStateDetector } from './stateDetector.js';
+import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
 export class SessionManager extends EventEmitter {
@@ -23,7 +24,7 @@ export class SessionManager extends EventEmitter {
         // Create a detector based on the session's detection strategy
         const strategy = session.detectionStrategy || 'claude';
         const detector = createStateDetector(strategy);
-        return detector.detectState(session.terminal);
+        return detector.detectState(session.terminal, session.state);
     }
     constructor() {
         super();
@@ -71,10 +72,13 @@ export class SessionManager extends EventEmitter {
             lastActivity: new Date(),
             isActive: false,
             terminal,
+            stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
             commandConfig,
             detectionStrategy: options.detectionStrategy ?? 'claude',
-            devcontainerConfig: options.devcontainerConfig,
+            devcontainerConfig: options.devcontainerConfig ?? undefined,
+            pendingState: undefined,
+            pendingStateStart: undefined,
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -188,16 +192,39 @@ export class SessionManager extends EventEmitter {
     setupBackgroundHandler(session) {
         // Setup data handler
         this.setupDataHandler(session);
+        // Set up interval-based state detection with persistence
         session.stateCheckInterval = setInterval(() => {
             const oldState = session.state;
-            const newState = this.detectTerminalState(session);
-            if (newState !== oldState) {
-                session.state = newState;
-                // Execute status hook asynchronously (non-blocking)
-                void executeStatusHook(oldState, newState, session);
-                this.emit('sessionStateChanged', session);
+            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;
+                }
+                else if (session.pendingState !== undefined &&
+                    session.pendingStateStart !== undefined) {
+                    // Check if the pending state has persisted long enough
+                    const duration = now - session.pendingStateStart;
+                    if (duration >= STATE_PERSISTENCE_DURATION_MS) {
+                        // Confirm the state change
+                        session.state = detectedState;
+                        session.pendingState = undefined;
+                        session.pendingStateStart = undefined;
+                        // Execute status hook asynchronously (non-blocking)
+                        void executeStatusHook(oldState, detectedState, session);
+                        this.emit('sessionStateChanged', session);
+                    }
+                }
+            }
+            else {
+                // Detected state matches current state, clear any pending state
+                session.pendingState = undefined;
+                session.pendingStateStart = undefined;
             }
-        }, 100); // Check every 100ms
+        }, STATE_CHECK_INTERVAL_MS);
         // Setup exit handler
         this.setupExitHandler(session);
     }
@@ -205,7 +232,11 @@ export class SessionManager extends EventEmitter {
         // Clear the state check interval
         if (session.stateCheckInterval) {
             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';
         this.emit('sessionStateChanged', session);

package/dist/services/sessionManager.statePersistence.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,215 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { SessionManager } from './sessionManager.js';
+import { spawn } from 'node-pty';
+import { EventEmitter } from 'events';
+import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
+vi.mock('node-pty');
+vi.mock('./configurationManager.js', () => ({
+    configurationManager: {
+        getConfig: vi.fn().mockReturnValue({
+            commands: [
+                {
+                    id: 'test',
+                    name: 'Test',
+                    command: 'test',
+                    args: [],
+                },
+            ],
+            defaultCommandId: 'test',
+        }),
+        getPresetById: vi.fn().mockReturnValue({
+            id: 'test',
+            name: 'Test',
+            command: 'test',
+            args: [],
+        }),
+        getDefaultPreset: vi.fn().mockReturnValue({
+            id: 'test',
+            name: 'Test',
+            command: 'test',
+            args: [],
+        }),
+        getHooks: vi.fn().mockReturnValue({}),
+        getStatusHooks: vi.fn().mockReturnValue({}),
+    },
+}));
+describe('SessionManager - State Persistence', () => {
+    let sessionManager;
+    let mockPtyInstances;
+    let eventEmitters;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        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();
+            eventEmitters.set(path, eventEmitter);
+            const mockPty = {
+                onData: vi.fn((callback) => {
+                    eventEmitter.on('data', callback);
+                    return { dispose: vi.fn() };
+                }),
+                onExit: vi.fn((callback) => {
+                    eventEmitter.on('exit', callback);
+                    return { dispose: vi.fn() };
+                }),
+                write: vi.fn(),
+                resize: vi.fn(),
+                kill: vi.fn(),
+                process: 'test',
+                pid: 12345 + mockPtyInstances.size,
+            };
+            mockPtyInstances.set(path, mockPty);
+            return mockPty;
+        });
+    });
+    afterEach(() => {
+        vi.clearAllTimers();
+        vi.useRealTimers();
+        vi.clearAllMocks();
+    });
+    it('should not change state immediately when detected state changes', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        // Initial state should be busy
+        expect(session.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);
+        // 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();
+    });
+    it('should change state after persistence duration is met', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.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');
+        expect(stateChangeHandler).not.toHaveBeenCalled();
+        // Advance time to exceed persistence duration
+        vi.advanceTimersByTime(STATE_PERSISTENCE_DURATION_MS);
+        // State should now be changed
+        expect(session.state).toBe('idle');
+        expect(session.pendingState).toBeUndefined();
+        expect(session.pendingStateStart).toBeUndefined();
+        expect(stateChangeHandler).toHaveBeenCalledWith(session);
+    });
+    it('should cancel pending state if detected state changes again before persistence', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        // Initial state should be busy
+        expect(session.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');
+        // Simulate output that would trigger waiting_input state
+        eventEmitter.emit('data', '│ Do you want to continue?');
+        // Advance time to trigger another check
+        vi.advanceTimersByTime(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');
+    });
+    it('should clear pending state if detected state returns to current state', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        // Initial state should be busy
+        expect(session.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();
+        // 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);
+        // Pending state should be cleared
+        expect(session.state).toBe('busy');
+        expect(session.pendingState).toBeUndefined();
+        expect(session.pendingStateStart).toBeUndefined();
+    });
+    it('should not confirm state changes that do not persist long enough', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.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
+        // Should have pending state but not confirmed
+        expect(session.state).toBe('busy');
+        expect(session.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[H│ Do you want to continue?\n');
+        // 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
+        // Pending state should have changed to waiting_input
+        expect(session.state).toBe('busy'); // Still original state
+        expect(session.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 session = await sessionManager.createSessionWithPreset('/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 less than persistence duration
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        expect(session.pendingState).toBe('idle');
+        expect(session.pendingStateStart).toBeDefined();
+        // Destroy the session
+        sessionManager.destroySession('/test/path');
+        // Check that pending state is cleared
+        const destroyedSession = sessionManager.getSession('/test/path');
+        expect(destroyedSession).toBeUndefined();
+    });
+    it('should handle multiple sessions with independent state persistence', async () => {
+        const session1 = await sessionManager.createSessionWithPreset('/test/path1');
+        const session2 = await sessionManager.createSessionWithPreset('/test/path2');
+        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');
+        // 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?');
+        // Advance time to check but not confirm
+        vi.advanceTimersByTime(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);
+        // 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();
+    });
+});

package/dist/services/stateDetector.d.ts

@@ -1,19 +1,19 @@
 import { SessionState, Terminal, StateDetectionStrategy } from '../types/index.js';
 export interface StateDetector {
-    detectState(terminal: Terminal): SessionState;
+    detectState(terminal: Terminal, currentState: SessionState): SessionState;
 }
 export declare function createStateDetector(strategy?: StateDetectionStrategy): StateDetector;
 export declare abstract class BaseStateDetector implements StateDetector {
-    abstract detectState(terminal: Terminal): SessionState;
+    abstract detectState(terminal: Terminal, currentState: SessionState): SessionState;
     protected getTerminalLines(terminal: Terminal, maxLines?: number): string[];
     protected getTerminalContent(terminal: Terminal, maxLines?: number): string;
 }
 export declare class ClaudeStateDetector extends BaseStateDetector {
-    detectState(terminal: Terminal): SessionState;
+    detectState(terminal: Terminal, currentState: SessionState): SessionState;
 }
 export declare class GeminiStateDetector extends BaseStateDetector {
-    detectState(terminal: Terminal): SessionState;
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
 }
 export declare class CodexStateDetector extends BaseStateDetector {
-    detectState(terminal: Terminal): SessionState;
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
 }

package/dist/services/stateDetector.js

@@ -32,9 +32,13 @@ export class BaseStateDetector {
     }
 }
 export class ClaudeStateDetector extends BaseStateDetector {
-    detectState(terminal) {
+    detectState(terminal, currentState) {
         const content = this.getTerminalContent(terminal);
         const lowerContent = content.toLowerCase();
+        // Check for ctrl+r toggle prompt - maintain current state
+        if (lowerContent.includes('ctrl+r to toggle')) {
+            return currentState;
+        }
         // Check for waiting prompts with box character
         if (content.includes('│ Do you want') ||
             content.includes('│ Would you like')) {
@@ -50,7 +54,7 @@ export class ClaudeStateDetector extends BaseStateDetector {
 }
 // https://github.com/google-gemini/gemini-cli/blob/main/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
 export class GeminiStateDetector extends BaseStateDetector {
-    detectState(terminal) {
+    detectState(terminal, _currentState) {
         const content = this.getTerminalContent(terminal);
         const lowerContent = content.toLowerCase();
         // Check for waiting prompts with box character
@@ -68,7 +72,7 @@ export class GeminiStateDetector extends BaseStateDetector {
     }
 }
 export class CodexStateDetector extends BaseStateDetector {
-    detectState(terminal) {
+    detectState(terminal, _currentState) {
         const content = this.getTerminalContent(terminal);
         const lowerContent = content.toLowerCase();
         // Check for waiting prompts

package/dist/services/stateDetector.test.js

@@ -33,7 +33,7 @@ describe('ClaudeStateDetector', () => {
                 '│ > ',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('waiting_input');
         });
@@ -45,7 +45,7 @@ describe('ClaudeStateDetector', () => {
                 '│ > ',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('waiting_input');
         });
@@ -56,7 +56,7 @@ describe('ClaudeStateDetector', () => {
                 'Press ESC to interrupt',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('busy');
         });
@@ -67,7 +67,7 @@ describe('ClaudeStateDetector', () => {
                 'press esc to interrupt the process',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('busy');
         });
@@ -79,7 +79,7 @@ describe('ClaudeStateDetector', () => {
                 '> ',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('idle');
         });
@@ -87,7 +87,7 @@ describe('ClaudeStateDetector', () => {
             // Arrange
             terminal = createMockTerminal([]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('idle');
         });
@@ -106,7 +106,7 @@ describe('ClaudeStateDetector', () => {
             }
             terminal = createMockTerminal(lines);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('idle'); // Should not detect the old prompt
         });
@@ -118,10 +118,42 @@ describe('ClaudeStateDetector', () => {
                 '│ > ',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('waiting_input'); // waiting_input should take precedence
         });
+        it('should maintain current state when "ctrl+r to toggle" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Some output',
+                'Press Ctrl+R to toggle history search',
+                'More output',
+            ]);
+            // Act - test with different current states
+            const idleState = detector.detectState(terminal, 'idle');
+            const busyState = detector.detectState(terminal, 'busy');
+            const waitingState = detector.detectState(terminal, 'waiting_input');
+            // Assert - should maintain whatever the current state was
+            expect(idleState).toBe('idle');
+            expect(busyState).toBe('busy');
+            expect(waitingState).toBe('waiting_input');
+        });
+        it('should maintain current state for various "ctrl+r" patterns', () => {
+            // Arrange - test different case variations
+            const patterns = [
+                'ctrl+r to toggle',
+                'CTRL+R TO TOGGLE',
+                'Ctrl+R to toggle history',
+                'Press ctrl+r to toggle the search',
+            ];
+            for (const pattern of patterns) {
+                terminal = createMockTerminal(['Some output', pattern]);
+                // Act
+                const state = detector.detectState(terminal, 'busy');
+                // Assert - should maintain the current state
+                expect(state).toBe('busy');
+            }
+        });
     });
 });
 describe('GeminiStateDetector', () => {
@@ -157,7 +189,7 @@ describe('GeminiStateDetector', () => {
                 '│ > ',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('waiting_input');
         });
@@ -169,7 +201,7 @@ describe('GeminiStateDetector', () => {
                 '│ > ',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('waiting_input');
         });
@@ -181,7 +213,7 @@ describe('GeminiStateDetector', () => {
                 '│ > ',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('waiting_input');
         });
@@ -192,7 +224,7 @@ describe('GeminiStateDetector', () => {
                 'Press ESC to cancel',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('busy');
         });
@@ -203,7 +235,7 @@ describe('GeminiStateDetector', () => {
                 'Press Esc to cancel the operation',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('busy');
         });
@@ -214,7 +246,7 @@ describe('GeminiStateDetector', () => {
                 'Type your message below',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('idle');
         });
@@ -222,7 +254,7 @@ describe('GeminiStateDetector', () => {
             // Arrange
             terminal = createMockTerminal([]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('idle');
         });
@@ -234,7 +266,7 @@ describe('GeminiStateDetector', () => {
                 '│ > ',
             ]);
             // Act
-            const state = detector.detectState(terminal);
+            const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('waiting_input'); // waiting_input should take precedence
         });
@@ -267,7 +299,7 @@ describe('CodexStateDetector', () => {
         // Arrange
         terminal = createMockTerminal(['Some output', '│Allow execution?', '│ > ']);
         // Act
-        const state = detector.detectState(terminal);
+        const state = detector.detectState(terminal, 'idle');
         // Assert
         expect(state).toBe('waiting_input');
     });
@@ -275,7 +307,7 @@ describe('CodexStateDetector', () => {
         // Arrange
         terminal = createMockTerminal(['Some output', 'Continue? [y/N]', '> ']);
         // Act
-        const state = detector.detectState(terminal);
+        const state = detector.detectState(terminal, 'idle');
         // Assert
         expect(state).toBe('waiting_input');
     });
@@ -286,7 +318,7 @@ describe('CodexStateDetector', () => {
             'Press any key to continue...',
         ]);
         // Act
-        const state = detector.detectState(terminal);
+        const state = detector.detectState(terminal, 'idle');
         // Assert
         expect(state).toBe('waiting_input');
     });
@@ -298,7 +330,7 @@ describe('CodexStateDetector', () => {
             'Working...',
         ]);
         // Act
-        const state = detector.detectState(terminal);
+        const state = detector.detectState(terminal, 'idle');
         // Assert
         expect(state).toBe('busy');
     });
@@ -310,7 +342,7 @@ describe('CodexStateDetector', () => {
             'Working...',
         ]);
         // Act
-        const state = detector.detectState(terminal);
+        const state = detector.detectState(terminal, 'idle');
         // Assert
         expect(state).toBe('busy');
     });
@@ -318,7 +350,7 @@ describe('CodexStateDetector', () => {
         // Arrange
         terminal = createMockTerminal(['Normal output', 'Some message', 'Ready']);
         // Act
-        const state = detector.detectState(terminal);
+        const state = detector.detectState(terminal, 'idle');
         // Assert
         expect(state).toBe('idle');
     });
@@ -326,7 +358,7 @@ describe('CodexStateDetector', () => {
         // Arrange
         terminal = createMockTerminal(['press esc to cancel', '[y/N]']);
         // Act
-        const state = detector.detectState(terminal);
+        const state = detector.detectState(terminal, 'idle');
         // Assert
         expect(state).toBe('waiting_input');
     });

package/dist/types/index.d.ts

@@ -22,11 +22,13 @@ export interface Session {
     lastActivity: Date;
     isActive: boolean;
     terminal: Terminal;
-    stateCheckInterval?: NodeJS.Timeout;
-    isPrimaryCommand?: boolean;
-    commandConfig?: CommandConfig;
-    detectionStrategy?: StateDetectionStrategy;
-    devcontainerConfig?: DevcontainerConfig;
+    stateCheckInterval: NodeJS.Timeout | undefined;
+    isPrimaryCommand: boolean;
+    commandConfig: CommandConfig | undefined;
+    detectionStrategy: StateDetectionStrategy | undefined;
+    devcontainerConfig: DevcontainerConfig | undefined;
+    pendingState: SessionState | undefined;
+    pendingStateStart: number | undefined;
 }
 export interface SessionManager {
     sessions: Map<string, Session>;

package/dist/utils/hookExecutor.test.js

@@ -257,6 +257,12 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 state: 'idle',
                 stateCheckInterval: undefined,
+                isPrimaryCommand: true,
+                commandConfig: undefined,
+                detectionStrategy: 'claude',
+                devcontainerConfig: undefined,
+                pendingState: undefined,
+                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
             };
@@ -304,6 +310,12 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 state: 'idle',
                 stateCheckInterval: undefined,
+                isPrimaryCommand: true,
+                commandConfig: undefined,
+                detectionStrategy: 'claude',
+                devcontainerConfig: undefined,
+                pendingState: undefined,
+                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
             };
@@ -349,6 +361,12 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 state: 'idle',
                 stateCheckInterval: undefined,
+                isPrimaryCommand: true,
+                commandConfig: undefined,
+                detectionStrategy: 'claude',
+                devcontainerConfig: undefined,
+                pendingState: undefined,
+                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
             };

package/dist/utils/worktreeUtils.test.js

@@ -105,6 +105,13 @@ describe('prepareWorktreeItems', () => {
         lastActivity: new Date(),
         isActive: true,
         terminal: {},
+        stateCheckInterval: undefined,
+        isPrimaryCommand: true,
+        commandConfig: undefined,
+        detectionStrategy: 'claude',
+        devcontainerConfig: undefined,
+        pendingState: undefined,
+        pendingStateStart: undefined,
     };
     it('should prepare basic worktree without git status', () => {
         const items = prepareWorktreeItems([mockWorktree], []);

package/package.json

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