ccmanager 4.1.0 → 4.1.2

package/dist/components/Session.js

@@ -61,11 +61,13 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             session.process.write(data);
         };
         stdin.on('data', handleStdinData);
-        // Prevent line wrapping from drifting redraws in TUIs that rely on cursor-up clears.
-        stdout.write('\x1b[?7l');
         // Clear screen when entering session
         stdout.write('\x1B[2J\x1B[H');
         // Restore the current terminal state from the headless xterm snapshot.
+        // The xterm serialize addon relies on auto-wrap (DECAWM) being enabled to
+        // render wrapped lines — it omits row separators for wrapped rows, expecting
+        // characters to naturally overflow to the next line.  We therefore keep
+        // auto-wrap enabled while writing the snapshot and only disable it afterward.
         const handleSessionRestore = (restoredSession, restoreSnapshot) => {
             if (restoredSession.id === session.id) {
                 if (restoreSnapshot.length > 0) {
@@ -107,8 +109,16 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             /* empty */
         }
         // Mark session as active after resizing so the restore snapshot matches
-        // the current terminal dimensions.
+        // the current terminal dimensions.  setSessionActive synchronously emits
+        // the 'sessionRestore' event, so the snapshot is written to stdout before
+        // we proceed.
         sessionManager.setSessionActive(session.id, true);
+        // Prevent line wrapping from drifting redraws in TUIs that rely on
+        // cursor-up clears.  This MUST come after the restore snapshot write
+        // because the xterm serialize addon relies on auto-wrap (DECAWM) being
+        // enabled — it omits row separators for wrapped rows, expecting characters
+        // to naturally overflow to the next line.
+        stdout.write('\x1b[?7l');
         // Handle terminal resize
         const handleResize = () => {
             const cols = process.stdout.columns || 80;

package/dist/components/Session.test.js

@@ -96,6 +96,7 @@ describe('Session', () => {
         expect(terminalResize).toHaveBeenCalledWith(120, 40);
         expect(processResize.mock.invocationCallOrder[0] ?? 0).toBeLessThan(setSessionActive.mock.invocationCallOrder[0] ?? 0);
         expect(terminalResize.mock.invocationCallOrder[0] ?? 0).toBeLessThan(setSessionActive.mock.invocationCallOrder[0] ?? 0);
-        expect(testState.stdout?.write).toHaveBeenNthCalledWith(3, '\nrestored');
+        expect(testState.stdout?.write).toHaveBeenNthCalledWith(2, '\nrestored');
+        expect(testState.stdout?.write).toHaveBeenNthCalledWith(3, '\x1b[?7l');
     });
 });

package/dist/services/sessionManager.js

@@ -201,7 +201,7 @@ export class SessionManager extends EventEmitter {
     }
     getRestoreSnapshot(session) {
         return session.serializer.serialize({
-            scrollback: TERMINAL_SCROLLBACK_LINES,
+            scrollback: 0,
         });
     }
     async createSessionInternal(worktreePath, ptyProcess, options = {}) {

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

@@ -4,6 +4,7 @@ import { SessionManager } from './sessionManager.js';
 import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
 import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, STATE_MINIMUM_DURATION_MS, } from '../constants/statePersistence.js';
+import { IDLE_DEBOUNCE_MS } from './stateDetector/claude.js';
 vi.mock('./bunTerminal.js', () => ({
     spawn: vi.fn(function () {
         return null;
@@ -86,8 +87,9 @@ describe('SessionManager - State Persistence', () => {
         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 (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
+        // Advance time past idle debounce so detector starts returning idle,
+        // but not enough for persistence to confirm
+        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
         // State should still be busy, but pending state should be set
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
@@ -103,8 +105,8 @@ describe('SessionManager - State Persistence', () => {
         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 (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
+        // Advance time past idle debounce but not persistence+minimum
+        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         expect(stateChangeHandler).not.toHaveBeenCalled();
         // Advance time past both persistence and minimum duration
@@ -123,8 +125,8 @@ describe('SessionManager - State Persistence', () => {
         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 (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
+        // Advance time past idle debounce so detector starts returning idle
+        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
         expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
         // Simulate output that would trigger waiting_input state
         eventEmitter.emit('data', 'Do you want to continue?\n❯ 1. Yes');
@@ -142,8 +144,8 @@ describe('SessionManager - State Persistence', () => {
         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 (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
+        // Advance time past idle debounce so detector starts returning idle
+        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
         expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
         expect(session.stateMutex.getSnapshot().pendingStateStart).toBeDefined();
         // Simulate output that would trigger busy state again (back to original)
@@ -165,16 +167,16 @@ describe('SessionManager - State Persistence', () => {
         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) (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS); // 100ms
+        // Wait past idle debounce so detector returns idle, then one check
+        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
         // Should have pending state but not confirmed
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
         // Now change to a different state before idle persists
         // Clear terminal first and add waiting prompt
         eventEmitter.emit('data', '\x1b[2J\x1b[HDo you want to continue?\n❯ 1. Yes');
-        // Advance time to detect new state 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
+        // Advance time to detect new state
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS);
         // Pending state should have changed to waiting_input
         expect(session.stateMutex.getSnapshot().state).toBe('busy'); // Still original state
         expect(session.stateMutex.getSnapshot().pendingState).toBe('waiting_input');
@@ -187,8 +189,8 @@ 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 (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
+        // Advance time past idle debounce so detector returns idle
+        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_CHECK_INTERVAL_MS);
         expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
         expect(session.stateMutex.getSnapshot().pendingStateStart).toBeDefined();
         // Destroy the session
@@ -207,8 +209,10 @@ describe('SessionManager - State Persistence', () => {
         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 so transition is not yet confirmed
-        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS - STATE_CHECK_INTERVAL_MS);
+        // Advance past idle debounce but not past persistence + minimum duration
+        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS +
+            STATE_PERSISTENCE_DURATION_MS -
+            STATE_CHECK_INTERVAL_MS);
         // State should still be busy because minimum duration hasn't elapsed
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         expect(stateChangeHandler).not.toHaveBeenCalled();
@@ -223,8 +227,8 @@ describe('SessionManager - State Persistence', () => {
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         // Simulate output that would trigger idle state
         eventEmitter.emit('data', 'Some output without busy indicators');
-        // Advance time past STATE_MINIMUM_DURATION_MS (which is longer than STATE_PERSISTENCE_DURATION_MS)
-        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_CHECK_INTERVAL_MS);
+        // Advance past idle debounce + persistence/minimum duration
+        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_MINIMUM_DURATION_MS + STATE_CHECK_INTERVAL_MS);
         // State should now be idle since both durations are satisfied
         expect(session.stateMutex.getSnapshot().state).toBe('idle');
         expect(stateChangeHandler).toHaveBeenCalledWith(session);
@@ -244,14 +248,11 @@ describe('SessionManager - State Persistence', () => {
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         // Now simulate a brief screen redraw: busy indicators disappear temporarily
         eventEmitter.emit('data', '\x1b[2J\x1b[H'); // Clear screen
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS); // 100ms
-        // Pending state should be set to idle
-        expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
-        // Advance past half the persistence duration but not fully
-        // Since stateConfirmedAt was updated at ~2000ms, this is not enough
-        // for the pending state to be confirmed
-        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS / 2);
-        // State should still be busy because minimum duration since last busy detection hasn't elapsed
+        // Idle debounce prevents the detector from returning idle for IDLE_DEBOUNCE_MS,
+        // so during a brief redraw (< 1500ms), no pending idle state is set.
+        // Advance a short time — still within the idle debounce window
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3); // 300ms
+        // State should still be busy — idle debounce hasn't elapsed
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         expect(stateChangeHandler).not.toHaveBeenCalled();
         // Simulate busy indicators coming back (screen redraw complete)
@@ -274,18 +275,12 @@ describe('SessionManager - State Persistence', () => {
         // 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
+        // Session 2 goes to waiting_input (no idle debounce for waiting_input)
         eventEmitter2.emit('data', 'Do you want to continue?\n❯ 1. Yes');
-        // 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.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 - need to exceed STATE_MINIMUM_DURATION_MS (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS);
+        // Advance past idle debounce for session 1 + persistence/minimum for both
+        await vi.advanceTimersByTimeAsync(IDLE_DEBOUNCE_MS + STATE_MINIMUM_DURATION_MS + STATE_CHECK_INTERVAL_MS);
         // Both should now be in their new states
+        // Session 2 (waiting_input) transitions faster since it's not debounced
         expect(session1.stateMutex.getSnapshot().state).toBe('idle');
         expect(session1.stateMutex.getSnapshot().pendingState).toBeUndefined();
         expect(session2.stateMutex.getSnapshot().state).toBe('waiting_input');

package/dist/services/sessionManager.test.js

@@ -774,7 +774,7 @@ describe('SessionManager', () => {
             const restoreHandler = vi.fn();
             sessionManager.on('sessionRestore', restoreHandler);
             sessionManager.setSessionActive(session.id, true);
-            expect(serializeMock).toHaveBeenCalledWith({ scrollback: 5000 });
+            expect(serializeMock).toHaveBeenCalledWith({ scrollback: 0 });
             expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mrestored\u001b[0m');
         });
         it('should skip restore event when serialized output is empty', async () => {

package/dist/services/stateDetector/claude.d.ts

@@ -1,6 +1,18 @@
 import { SessionState, Terminal } from '../../types/index.js';
 import { BaseStateDetector } from './base.js';
+export declare const IDLE_DEBOUNCE_MS = 1500;
 export declare class ClaudeStateDetector extends BaseStateDetector {
+    private lastContentHash;
+    private contentStableSince;
+    /**
+     * Debounce idle transitions: only return 'idle' when the terminal
+     * content has been unchanged for IDLE_DEBOUNCE_MS.
+     * Returns currentState if output is still changing.
+     *
+     * This is a workaround for Claude Code occasionally showing idle-like
+     * terminal output while still busy (e.g. during screen redraws).
+     */
+    private debounceIdle;
     /**
      * Extract content above the prompt box.
      * The prompt box is delimited by ─ border lines:

package/dist/services/stateDetector/claude.js

@@ -4,7 +4,34 @@ const SPINNER_CHARS = '✱✲✳✴✵✶✷✸✹✺✻✼✽✾✿❀❁❂❃
 // Matches spinner activity labels like "✽ Tempering…" or "✳ Simplifying recompute_tangents…"
 const SPINNER_ACTIVITY_PATTERN = new RegExp(`^[${SPINNER_CHARS}] \\S+ing.*\u2026`, 'm');
 const BUSY_LOOKBACK_LINES = 5;
+// Workaround: Claude Code sometimes appears idle in terminal output while
+// still actively processing (busy). To mitigate false idle transitions,
+// require terminal output to remain unchanged for this duration before
+// confirming the idle state.
+export const IDLE_DEBOUNCE_MS = 1500;
 export class ClaudeStateDetector extends BaseStateDetector {
+    lastContentHash = '';
+    contentStableSince = 0;
+    /**
+     * Debounce idle transitions: only return 'idle' when the terminal
+     * content has been unchanged for IDLE_DEBOUNCE_MS.
+     * Returns currentState if output is still changing.
+     *
+     * This is a workaround for Claude Code occasionally showing idle-like
+     * terminal output while still busy (e.g. during screen redraws).
+     */
+    debounceIdle(terminal, currentState, now = Date.now()) {
+        const content = this.getTerminalContent(terminal, 30);
+        if (content !== this.lastContentHash) {
+            this.lastContentHash = content;
+            this.contentStableSince = now;
+        }
+        const stableDuration = now - this.contentStableSince;
+        if (stableDuration >= IDLE_DEBOUNCE_MS) {
+            return 'idle';
+        }
+        return currentState;
+    }
     /**
      * Extract content above the prompt box.
      * The prompt box is delimited by ─ border lines:
@@ -62,10 +89,10 @@ export class ClaudeStateDetector extends BaseStateDetector {
         return recentBlock.slice(-BUSY_LOOKBACK_LINES).join('\n');
     }
     detectState(terminal, currentState) {
-        // Check for search prompt (⌕ Search…) within 200 lines - always idle
+        // Check for search prompt (⌕ Search…) within 200 lines - always idle (debounced)
         const extendedContent = this.getTerminalContent(terminal, 200);
         if (extendedContent.includes('⌕ Search…')) {
-            return 'idle';
+            return this.debounceIdle(terminal, currentState);
         }
         // Full content (including prompt box) for waiting_input detection
         const fullContent = this.getTerminalContent(terminal, 30);
@@ -79,10 +106,6 @@ export class ClaudeStateDetector extends BaseStateDetector {
         if (/(?:do you want|would you like).+\n+[\s\S]*?(?:yes|❯)/.test(fullLowerContent)) {
             return 'waiting_input';
         }
-        // Check for selection prompt with ❯ cursor indicator and numbered options
-        if (/❯\s+\d+\./.test(fullContent)) {
-            return 'waiting_input';
-        }
         // Check for "esc to cancel" - indicates waiting for user input
         if (fullLowerContent.includes('esc to cancel')) {
             return 'waiting_input';
@@ -99,8 +122,8 @@ export class ClaudeStateDetector extends BaseStateDetector {
         if (SPINNER_ACTIVITY_PATTERN.test(abovePromptBox)) {
             return 'busy';
         }
-        // Otherwise idle
-        return 'idle';
+        // Otherwise idle (debounced)
+        return this.debounceIdle(terminal, currentState);
     }
     detectBackgroundTask(terminal) {
         const lines = this.getTerminalLines(terminal, 3);

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

@@ -1,12 +1,25 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { ClaudeStateDetector } from './claude.js';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { ClaudeStateDetector, IDLE_DEBOUNCE_MS } from './claude.js';
 import { createMockTerminal } from './testUtils.js';
 describe('ClaudeStateDetector', () => {
     let detector;
     let terminal;
     beforeEach(() => {
+        vi.useFakeTimers();
         detector = new ClaudeStateDetector();
     });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    /**
+     * Helper: call detectState, advance time past IDLE_DEBOUNCE_MS,
+     * then call again with the same terminal to get the debounced result.
+     */
+    const detectStateAfterDebounce = (det, term, currentState = 'idle') => {
+        det.detectState(term, currentState);
+        vi.advanceTimersByTime(IDLE_DEBOUNCE_MS);
+        return det.detectState(term, currentState);
+    };
     describe('detectState', () => {
         it('should detect busy when "ESC to interrupt" is above prompt box', () => {
             // Arrange
@@ -47,7 +60,7 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('busy');
         });
-        it('should detect idle when no specific patterns are found', () => {
+        it('should detect idle when no specific patterns are found (after debounce)', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Command completed successfully',
@@ -55,7 +68,7 @@ describe('ClaudeStateDetector', () => {
                 '> ',
             ]);
             // Act
-            const state = detector.detectState(terminal, 'idle');
+            const state = detectStateAfterDebounce(detector, terminal, 'idle');
             // Assert
             expect(state).toBe('idle');
         });
@@ -63,7 +76,7 @@ describe('ClaudeStateDetector', () => {
             // Arrange
             terminal = createMockTerminal([]);
             // Act
-            const state = detector.detectState(terminal, 'idle');
+            const state = detectStateAfterDebounce(detector, terminal, 'idle');
             // Assert
             expect(state).toBe('idle');
         });
@@ -202,33 +215,6 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('waiting_input');
         });
-        it('should detect waiting_input when plan submit prompt with ❯ cursor is present', () => {
-            // Arrange
-            terminal = createMockTerminal([
-                'Ready to submit your answers?',
-                '',
-                '❯ 1. Submit answers',
-                '  2. Cancel',
-            ]);
-            // Act
-            const state = detector.detectState(terminal, 'idle');
-            // Assert
-            expect(state).toBe('waiting_input');
-        });
-        it('should detect waiting_input for generic ❯ numbered selection prompt', () => {
-            // Arrange
-            terminal = createMockTerminal([
-                'Select an option:',
-                '',
-                '❯ 1. Option A',
-                '  2. Option B',
-                '  3. Option C',
-            ]);
-            // Act
-            const state = detector.detectState(terminal, 'idle');
-            // Assert
-            expect(state).toBe('waiting_input');
-        });
         it('should detect waiting_input when "esc to cancel" is above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([
@@ -283,7 +269,7 @@ describe('ClaudeStateDetector', () => {
                 'idle state here',
             ], { baseY: 5, rows: 3 });
             // Act
-            const state = detector.detectState(terminal, 'busy');
+            const state = detectStateAfterDebounce(detector, terminal, 'busy');
             // Assert - Should detect idle because viewport shows lines 5-7
             expect(state).toBe('idle');
         });
@@ -387,7 +373,7 @@ describe('ClaudeStateDetector', () => {
             // Arrange - no "ing…" at end
             terminal = createMockTerminal(['✽ Some random text', '❯']);
             // Act
-            const state = detector.detectState(terminal, 'idle');
+            const state = detectStateAfterDebounce(detector, terminal, 'idle');
             // Assert
             expect(state).toBe('idle');
         });
@@ -395,7 +381,7 @@ describe('ClaudeStateDetector', () => {
             // Arrange
             terminal = createMockTerminal(['⌕ Search…', '✽ Tempering…']);
             // Act
-            const state = detector.detectState(terminal, 'busy');
+            const state = detectStateAfterDebounce(detector, terminal, 'busy');
             // Assert - Search prompt takes precedence
             expect(state).toBe('idle');
         });
@@ -403,7 +389,7 @@ describe('ClaudeStateDetector', () => {
             // Arrange - Search prompt should always be idle
             terminal = createMockTerminal(['⌕ Search…', 'Some content']);
             // Act
-            const state = detector.detectState(terminal, 'busy');
+            const state = detectStateAfterDebounce(detector, terminal, 'busy');
             // Assert
             expect(state).toBe('idle');
         });
@@ -411,7 +397,7 @@ describe('ClaudeStateDetector', () => {
             // Arrange
             terminal = createMockTerminal(['⌕ Search…', 'esc to cancel']);
             // Act
-            const state = detector.detectState(terminal, 'idle');
+            const state = detectStateAfterDebounce(detector, terminal, 'idle');
             // Assert - Should be idle because search prompt takes precedence
             expect(state).toBe('idle');
         });
@@ -419,7 +405,7 @@ describe('ClaudeStateDetector', () => {
             // Arrange
             terminal = createMockTerminal(['⌕ Search…', 'Press esc to interrupt']);
             // Act
-            const state = detector.detectState(terminal, 'idle');
+            const state = detectStateAfterDebounce(detector, terminal, 'idle');
             // Assert - Should be idle because search prompt takes precedence
             expect(state).toBe('idle');
         });
@@ -437,7 +423,7 @@ describe('ClaudeStateDetector', () => {
                 '❯',
                 '──────────────────────────────',
             ]);
-            const state = detector.detectState(terminal, 'busy');
+            const state = detectStateAfterDebounce(detector, terminal, 'busy');
             expect(state).toBe('idle');
         });
         it('should ignore stale interrupt text outside the latest block above the prompt box', () => {
@@ -451,7 +437,7 @@ describe('ClaudeStateDetector', () => {
                 '❯',
                 '──────────────────────────────',
             ]);
-            const state = detector.detectState(terminal, 'busy');
+            const state = detectStateAfterDebounce(detector, terminal, 'busy');
             expect(state).toBe('idle');
         });
         it('should ignore "esc to interrupt" inside prompt box', () => {
@@ -463,7 +449,7 @@ describe('ClaudeStateDetector', () => {
                 '──────────────────────────────',
             ]);
             // Act
-            const state = detector.detectState(terminal, 'idle');
+            const state = detectStateAfterDebounce(detector, terminal, 'idle');
             // Assert - should be idle because "esc to interrupt" is inside prompt box
             expect(state).toBe('idle');
         });
@@ -503,10 +489,68 @@ describe('ClaudeStateDetector', () => {
                 '──────────────────────────────',
             ]);
             // Act
-            const state = detector.detectState(terminal, 'idle');
+            const state = detectStateAfterDebounce(detector, terminal, 'idle');
             // Assert - should be idle because spinner is inside prompt box
             expect(state).toBe('idle');
         });
+        describe('idle debounce', () => {
+            it('should not return idle immediately when output just appeared', () => {
+                terminal = createMockTerminal(['Command completed successfully', '> ']);
+                const state = detector.detectState(terminal, 'busy');
+                // Should remain busy because debounce hasn't elapsed
+                expect(state).toBe('busy');
+            });
+            it('should return idle after output is stable for IDLE_DEBOUNCE_MS', () => {
+                terminal = createMockTerminal(['Command completed successfully', '> ']);
+                // First call registers the content
+                detector.detectState(terminal, 'busy');
+                // Advance time past debounce threshold
+                vi.advanceTimersByTime(IDLE_DEBOUNCE_MS);
+                // Second call with same content should return idle
+                const state = detector.detectState(terminal, 'busy');
+                expect(state).toBe('idle');
+            });
+            it('should reset debounce timer when output changes', () => {
+                terminal = createMockTerminal(['Output v1', '> ']);
+                detector.detectState(terminal, 'busy');
+                // Advance almost to threshold
+                vi.advanceTimersByTime(IDLE_DEBOUNCE_MS - 100);
+                // Output changes
+                terminal = createMockTerminal(['Output v2', '> ']);
+                const state1 = detector.detectState(terminal, 'busy');
+                expect(state1).toBe('busy');
+                // Advance past original threshold but not new one
+                vi.advanceTimersByTime(200);
+                const state2 = detector.detectState(terminal, 'busy');
+                expect(state2).toBe('busy');
+                // Advance to meet new threshold
+                vi.advanceTimersByTime(IDLE_DEBOUNCE_MS);
+                const state3 = detector.detectState(terminal, 'busy');
+                expect(state3).toBe('idle');
+            });
+            it('should not debounce busy transitions', () => {
+                terminal = createMockTerminal([
+                    'Processing...',
+                    'Press ESC to interrupt',
+                    '──────────────────────────────',
+                    '❯',
+                    '──────────────────────────────',
+                ]);
+                // Busy should be detected immediately without debounce
+                const state = detector.detectState(terminal, 'idle');
+                expect(state).toBe('busy');
+            });
+            it('should not debounce waiting_input transitions', () => {
+                terminal = createMockTerminal([
+                    'Do you want to continue?',
+                    '❯ 1. Yes',
+                    '  2. No',
+                ]);
+                // waiting_input should be detected immediately
+                const state = detector.detectState(terminal, 'idle');
+                expect(state).toBe('waiting_input');
+            });
+        });
     });
     describe('detectBackgroundTask', () => {
         it('should return count 1 when "1 background task" is in status bar', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.1.0",
+	"version": "4.1.2",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.0",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.0",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.0",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.1.0",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.1.0"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.2",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.2",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.2",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.1.2",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.1.2"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",