ccmanager 3.3.1 → 3.4.0

package/dist/components/Menu.recent-projects.test.js

@@ -123,6 +123,7 @@ describe('Menu - Recent Projects', () => {
             waiting_input: 0,
             pending_auto_approval: 0,
             total: 0,
+            backgroundTasks: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
         const { lastFrame } = render(React.createElement(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true }));
@@ -153,6 +154,7 @@ describe('Menu - Recent Projects', () => {
             waiting_input: 0,
             pending_auto_approval: 0,
             total: 0,
+            backgroundTasks: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
         const { lastFrame } = render(React.createElement(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true }));

package/dist/components/Menu.test.js

@@ -276,6 +276,7 @@ describe('Menu component rendering', () => {
             waiting_input: 0,
             pending_auto_approval: 0,
             total: 0,
+            backgroundTasks: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
         const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true }));
@@ -317,6 +318,7 @@ describe('Menu component rendering', () => {
             waiting_input: 0,
             pending_auto_approval: 0,
             total: 0,
+            backgroundTasks: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
         const { lastFrame } = render(React.createElement(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true }));

package/dist/components/Session.js

@@ -1,68 +1,9 @@
-import React, { useEffect, useMemo, useState } from 'react';
-import { Box, Text, useStdout } from 'ink';
+import { useEffect, useState } from 'react';
+import { useStdout } from 'ink';
 import { shortcutManager } from '../services/shortcutManager.js';
 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 (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 (stateData.state === 'pending_auto_approval') {
-            return {
-                message: 'Auto-approval pending... verifying permissions (press any key to cancel)',
-                variant: 'pending',
-            };
-        }
-        return { message: null, variant: null };
-    };
-    const initialStatus = deriveStatus(session);
-    const [statusMessage, setStatusMessage] = useState(initialStatus.message);
-    const [statusVariant, setStatusVariant] = useState(initialStatus.variant);
-    const [columns, setColumns] = useState(() => stdout?.columns ?? process.stdout.columns ?? 80);
-    const { statusLineText, backgroundColor, textColor } = useMemo(() => {
-        if (!statusMessage || !statusVariant) {
-            return {
-                statusLineText: null,
-                backgroundColor: undefined,
-                textColor: undefined,
-            };
-        }
-        const maxContentWidth = Math.max(columns - 4, 0);
-        const prefix = statusVariant === 'error'
-            ? '[AUTO-APPROVAL REQUIRED]'
-            : '[AUTO-APPROVAL]';
-        const prefixed = `${prefix} ${statusMessage}`;
-        const trimmed = prefixed.length > maxContentWidth
-            ? prefixed.slice(0, maxContentWidth)
-            : prefixed;
-        return {
-            statusLineText: ` ${trimmed}`.padEnd(columns, ' '),
-            backgroundColor: statusVariant === 'error' ? '#d90429' : '#ffd166',
-            textColor: statusVariant === 'error' ? 'white' : '#1c1c1c',
-        };
-    }, [columns, statusMessage, statusVariant]);
-    useEffect(() => {
-        const handleSessionStateChange = (updatedSession) => {
-            if (updatedSession.id !== session.id)
-                return;
-            const { message, variant } = deriveStatus(updatedSession);
-            setStatusMessage(message);
-            setStatusVariant(variant);
-        };
-        sessionManager.on('sessionStateChanged', handleSessionStateChange);
-        return () => {
-            sessionManager.off('sessionStateChanged', handleSessionStateChange);
-        };
-    }, [session.id, sessionManager]);
     const stripOscColorSequences = (input) => {
         // Remove default foreground/background color OSC sequences that Codex emits
         // These sequences leak as literal text when replaying buffered output
@@ -168,7 +109,6 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         const handleSessionExit = (exitedSession) => {
             if (exitedSession.id === session.id) {
                 setIsExiting(true);
-                setStatusMessage(null);
                 // Don't call onReturnToMenu here - App component handles it
             }
         };
@@ -178,7 +118,6 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         const handleResize = () => {
             const cols = process.stdout.columns || 80;
             const rows = process.stdout.rows || 24;
-            setColumns(cols);
             session.process.resize(cols, rows);
             // Also resize the virtual terminal
             if (session.terminal) {
@@ -244,7 +183,6 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             stdout.off('resize', handleResize);
         };
     }, [session, sessionManager, stdout, onReturnToMenu, isExiting]);
-    return statusLineText ? (React.createElement(Box, { width: "100%" },
-        React.createElement(Text, { backgroundColor: backgroundColor, color: textColor, bold: true }, statusLineText))) : null;
+    return null;
 };
 export default Session;

package/dist/constants/statusIcons.d.ts

@@ -10,6 +10,9 @@ export declare const STATUS_LABELS: {
     readonly PENDING_AUTO_APPROVAL: "Pending Auto Approval";
     readonly IDLE: "Idle";
 };
+export declare const STATUS_TAGS: {
+    readonly BACKGROUND_TASK: "\u001B[2m[BG]\u001B[0m";
+};
 export declare const MENU_ICONS: {
     readonly NEW_WORKTREE: "⊕";
     readonly MERGE_WORKTREE: "⇄";
@@ -17,4 +20,4 @@ export declare const MENU_ICONS: {
     readonly CONFIGURE_SHORTCUTS: "⌨";
     readonly EXIT: "⏻";
 };
-export declare const getStatusDisplay: (status: SessionState) => string;
+export declare const getStatusDisplay: (status: SessionState, hasBackgroundTask?: boolean) => string;

package/dist/constants/statusIcons.js

@@ -9,6 +9,9 @@ export const STATUS_LABELS = {
     PENDING_AUTO_APPROVAL: 'Pending Auto Approval',
     IDLE: 'Idle',
 };
+export const STATUS_TAGS = {
+    BACKGROUND_TASK: '\x1b[2m[BG]\x1b[0m',
+};
 export const MENU_ICONS = {
     NEW_WORKTREE: '⊕',
     MERGE_WORKTREE: '⇄',
@@ -16,7 +19,7 @@ export const MENU_ICONS = {
     CONFIGURE_SHORTCUTS: '⌨',
     EXIT: '⏻',
 };
-export const getStatusDisplay = (status) => {
+const getBaseStatusDisplay = (status) => {
     switch (status) {
         case 'busy':
             return `${STATUS_ICONS.BUSY} ${STATUS_LABELS.BUSY}`;
@@ -28,3 +31,9 @@ export const getStatusDisplay = (status) => {
             return `${STATUS_ICONS.IDLE} ${STATUS_LABELS.IDLE}`;
     }
 };
+export const getStatusDisplay = (status, hasBackgroundTask = false) => {
+    const display = getBaseStatusDisplay(status);
+    return hasBackgroundTask
+        ? `${display} ${STATUS_TAGS.BACKGROUND_TASK}`
+        : display;
+};

package/dist/constants/statusIcons.test.d.ts

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

package/dist/constants/statusIcons.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { getStatusDisplay, STATUS_ICONS, STATUS_LABELS, STATUS_TAGS, } from './statusIcons.js';
+describe('getStatusDisplay', () => {
+    it('should return busy display for busy state', () => {
+        const result = getStatusDisplay('busy');
+        expect(result).toBe(`${STATUS_ICONS.BUSY} ${STATUS_LABELS.BUSY}`);
+    });
+    it('should return waiting display for waiting_input state', () => {
+        const result = getStatusDisplay('waiting_input');
+        expect(result).toBe(`${STATUS_ICONS.WAITING} ${STATUS_LABELS.WAITING}`);
+    });
+    it('should return pending auto approval display', () => {
+        const result = getStatusDisplay('pending_auto_approval');
+        expect(result).toBe(`${STATUS_ICONS.WAITING} ${STATUS_LABELS.PENDING_AUTO_APPROVAL}`);
+    });
+    it('should return idle display for idle state', () => {
+        const result = getStatusDisplay('idle');
+        expect(result).toBe(`${STATUS_ICONS.IDLE} ${STATUS_LABELS.IDLE}`);
+    });
+    describe('background task indicator', () => {
+        it('should append [BG] badge when idle and hasBackgroundTask is true', () => {
+            const result = getStatusDisplay('idle', true);
+            expect(result).toBe(`${STATUS_ICONS.IDLE} ${STATUS_LABELS.IDLE} ${STATUS_TAGS.BACKGROUND_TASK}`);
+        });
+        it('should not append [BG] badge when idle and hasBackgroundTask is false', () => {
+            const result = getStatusDisplay('idle', false);
+            expect(result).toBe(`${STATUS_ICONS.IDLE} ${STATUS_LABELS.IDLE}`);
+        });
+        it('should append [BG] badge when busy and hasBackgroundTask is true', () => {
+            const result = getStatusDisplay('busy', true);
+            expect(result).toBe(`${STATUS_ICONS.BUSY} ${STATUS_LABELS.BUSY} ${STATUS_TAGS.BACKGROUND_TASK}`);
+        });
+        it('should append [BG] badge when waiting_input and hasBackgroundTask is true', () => {
+            const result = getStatusDisplay('waiting_input', true);
+            expect(result).toBe(`${STATUS_ICONS.WAITING} ${STATUS_LABELS.WAITING} ${STATUS_TAGS.BACKGROUND_TASK}`);
+        });
+        it('should append [BG] badge when pending_auto_approval and hasBackgroundTask is true', () => {
+            const result = getStatusDisplay('pending_auto_approval', true);
+            expect(result).toBe(`${STATUS_ICONS.WAITING} ${STATUS_LABELS.PENDING_AUTO_APPROVAL} ${STATUS_TAGS.BACKGROUND_TASK}`);
+        });
+    });
+});

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

@@ -15,7 +15,10 @@ vi.mock('./bunTerminal.js', () => ({
     }),
 }));
 vi.mock('./stateDetector/index.js', () => ({
-    createStateDetector: () => ({ detectState: detectStateMock }),
+    createStateDetector: () => ({
+        detectState: detectStateMock,
+        detectBackgroundTask: () => false,
+    }),
 }));
 vi.mock('./configurationManager.js', () => ({
     configurationManager: {

package/dist/services/sessionManager.d.ts

@@ -8,6 +8,7 @@ export interface SessionCounts {
     waiting_input: number;
     pending_auto_approval: number;
     total: number;
+    backgroundTasks: number;
 }
 export declare class SessionManager extends EventEmitter implements ISessionManager {
     sessions: Map<string, Session>;
@@ -15,6 +16,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private busyTimers;
     private spawn;
     detectTerminalState(session: Session): SessionState;
+    detectBackgroundTask(session: Session): boolean;
     private getTerminalContent;
     private handleAutoApproval;
     private cancelAutoApprovalVerification;

package/dist/services/sessionManager.js

@@ -12,6 +12,7 @@ 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';
+import { STATUS_TAGS } from '../constants/statusIcons.js';
 import { getTerminalScreenContent } from '../utils/screenCapture.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
@@ -28,11 +29,8 @@ export class SessionManager extends EventEmitter {
         return spawn(command, args, spawnOptions);
     }
     detectTerminalState(session) {
-        // Create a detector based on the session's detection strategy
-        const strategy = session.detectionStrategy || 'claude';
-        const detector = createStateDetector(strategy);
         const stateData = session.stateMutex.getSnapshot();
-        const detectedState = detector.detectState(session.terminal, stateData.state);
+        const detectedState = session.stateDetector.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() &&
@@ -41,6 +39,9 @@ export class SessionManager extends EventEmitter {
         }
         return detectedState;
     }
+    detectBackgroundTask(session) {
+        return session.stateDetector.detectBackgroundTask(session.terminal);
+    }
     getTerminalContent(session) {
         // Use the new screen capture utility that correctly handles
         // both normal and alternate screen buffers
@@ -190,6 +191,8 @@ export class SessionManager extends EventEmitter {
     async createSessionInternal(worktreePath, ptyProcess, commandConfig, options = {}) {
         const id = this.createSessionId();
         const terminal = this.createTerminal();
+        const detectionStrategy = options.detectionStrategy ?? 'claude';
+        const stateDetector = createStateDetector(detectionStrategy);
         const session = {
             id,
             worktreePath,
@@ -202,9 +205,10 @@ export class SessionManager extends EventEmitter {
             stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
             commandConfig,
-            detectionStrategy: options.detectionStrategy ?? 'claude',
+            detectionStrategy,
             devcontainerConfig: options.devcontainerConfig ?? undefined,
             stateMutex: new Mutex(createInitialSessionStateData()),
+            stateDetector,
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -426,6 +430,14 @@ export class SessionManager extends EventEmitter {
                 !currentStateData.autoApprovalAbortController) {
                 this.handleAutoApproval(session);
             }
+            // Detect and update background task flag
+            const hasBackgroundTask = this.detectBackgroundTask(session);
+            if (currentStateData.hasBackgroundTask !== hasBackgroundTask) {
+                void session.stateMutex.update(data => ({
+                    ...data,
+                    hasBackgroundTask,
+                }));
+            }
         }, STATE_CHECK_INTERVAL_MS);
         // Setup exit handler
         this.setupExitHandler(session);
@@ -677,6 +689,7 @@ export class SessionManager extends EventEmitter {
             waiting_input: 0,
             pending_auto_approval: 0,
             total: sessions.length,
+            backgroundTasks: 0,
         };
         sessions.forEach(session => {
             const stateData = session.stateMutex.getSnapshot();
@@ -694,6 +707,9 @@ export class SessionManager extends EventEmitter {
                     counts.pending_auto_approval++;
                     break;
             }
+            if (stateData.hasBackgroundTask) {
+                counts.backgroundTasks++;
+            }
         });
         return counts;
     }
@@ -711,6 +727,10 @@ export class SessionManager extends EventEmitter {
         if (counts.waiting_input > 0) {
             parts.push(`${counts.waiting_input} Waiting`);
         }
-        return parts.length > 0 ? ` (${parts.join(' / ')})` : '';
+        if (parts.length === 0) {
+            return '';
+        }
+        const bgTag = counts.backgroundTasks > 0 ? ` ${STATUS_TAGS.BACKGROUND_TASK}` : '';
+        return ` (${parts.join(' / ')}${bgTag})`;
     }
 }

package/dist/services/sessionManager.test.js

@@ -720,10 +720,10 @@ describe('SessionManager', () => {
     describe('static methods', () => {
         describe('getSessionCounts', () => {
             // Helper to create mock session with stateMutex
-            const createMockSession = (id, state) => ({
+            const createMockSession = (id, state, hasBackgroundTask = false) => ({
                 id,
                 stateMutex: {
-                    getSnapshot: () => ({ state }),
+                    getSnapshot: () => ({ state, hasBackgroundTask }),
                 },
             });
             it('should count sessions by state', () => {
@@ -768,6 +768,7 @@ describe('SessionManager', () => {
                     waiting_input: 1,
                     pending_auto_approval: 0,
                     total: 4,
+                    backgroundTasks: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).toBe(' (1 Idle / 2 Busy / 1 Waiting)');
@@ -779,6 +780,7 @@ describe('SessionManager', () => {
                     waiting_input: 1,
                     pending_auto_approval: 0,
                     total: 3,
+                    backgroundTasks: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).toBe(' (2 Idle / 1 Waiting)');
@@ -790,6 +792,7 @@ describe('SessionManager', () => {
                     waiting_input: 0,
                     pending_auto_approval: 0,
                     total: 3,
+                    backgroundTasks: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).toBe(' (3 Busy)');
@@ -801,10 +804,24 @@ describe('SessionManager', () => {
                     waiting_input: 0,
                     pending_auto_approval: 0,
                     total: 0,
+                    backgroundTasks: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).toBe('');
             });
+            it('should append [BG] tag when background tasks exist', () => {
+                const counts = {
+                    idle: 1,
+                    busy: 1,
+                    waiting_input: 0,
+                    pending_auto_approval: 0,
+                    total: 2,
+                    backgroundTasks: 1,
+                };
+                const formatted = SessionManager.formatSessionCounts(counts);
+                expect(formatted).toContain('[BG]');
+                expect(formatted).toBe(' (1 Idle / 1 Busy \x1b[2m[BG]\x1b[0m)');
+            });
         });
     });
 });

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

@@ -4,4 +4,5 @@ export declare abstract class BaseStateDetector implements StateDetector {
     abstract detectState(terminal: Terminal, currentState: SessionState): SessionState;
     protected getTerminalLines(terminal: Terminal, maxLines?: number): string[];
     protected getTerminalContent(terminal: Terminal, maxLines?: number): string;
+    abstract detectBackgroundTask(terminal: Terminal): boolean;
 }

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

@@ -2,4 +2,5 @@ import { SessionState, Terminal } from '../../types/index.js';
 import { BaseStateDetector } from './base.js';
 export declare class ClaudeStateDetector extends BaseStateDetector {
     detectState(terminal: Terminal, currentState: SessionState): SessionState;
+    detectBackgroundTask(terminal: Terminal): boolean;
 }

package/dist/services/stateDetector/claude.js

@@ -24,4 +24,12 @@ export class ClaudeStateDetector extends BaseStateDetector {
         // Otherwise idle
         return 'idle';
     }
+    detectBackgroundTask(terminal) {
+        const lines = this.getTerminalLines(terminal, 3);
+        const content = lines.join('\n').toLowerCase();
+        // Detect background task patterns:
+        // - "N background task(s)" in status bar
+        // - "(running)" in status bar for active background commands
+        return content.includes('background task') || content.includes('(running)');
+    }
 }

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

@@ -222,4 +222,106 @@ describe('ClaudeStateDetector', () => {
             expect(state).toBe('waiting_input');
         });
     });
+    describe('detectBackgroundTask', () => {
+        it('should detect background task when pattern is in last 3 lines (status bar)', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Previous conversation content',
+                'More content',
+                '> Some command output',
+                '1 background task | api-call',
+            ]);
+            // Act
+            const hasBackgroundTask = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(hasBackgroundTask).toBe(true);
+        });
+        it('should detect background task with plural "background tasks"', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Some output',
+                'More output',
+                '2 background tasks running',
+            ]);
+            // Act
+            const hasBackgroundTask = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(hasBackgroundTask).toBe(true);
+        });
+        it('should detect background task case-insensitively', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Output line 1',
+                'Output line 2',
+                '1 BACKGROUND TASK running',
+            ]);
+            // Act
+            const hasBackgroundTask = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(hasBackgroundTask).toBe(true);
+        });
+        it('should return false when no background task pattern in last 3 lines', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Command completed successfully',
+                'Ready for next command',
+                '> ',
+            ]);
+            // Act
+            const hasBackgroundTask = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(hasBackgroundTask).toBe(false);
+        });
+        it('should not detect background task when pattern is in conversation content (not status bar)', () => {
+            // Arrange - "background task" mentioned earlier in conversation, but not in last 3 lines
+            terminal = createMockTerminal([
+                'User: Tell me about background task handling',
+                'Assistant: Background task detection works by...',
+                'The pattern "background task" appears in text but...',
+                'This is the status bar area',
+                '> idle',
+                'Ready',
+            ]);
+            // Act
+            const hasBackgroundTask = detector.detectBackgroundTask(terminal);
+            // Assert - should only check last 3 lines, not the conversation content
+            expect(hasBackgroundTask).toBe(false);
+        });
+        it('should handle empty terminal', () => {
+            // Arrange
+            terminal = createMockTerminal([]);
+            // Act
+            const hasBackgroundTask = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(hasBackgroundTask).toBe(false);
+        });
+        it('should handle terminal with fewer than 3 lines', () => {
+            // Arrange
+            terminal = createMockTerminal(['1 background task']);
+            // Act
+            const hasBackgroundTask = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(hasBackgroundTask).toBe(true);
+        });
+        it('should detect "(running)" status bar indicator', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Some conversation output',
+                'More output',
+                'bypass permissions on - uv run pytest tests/integration/e2e/tes... (running)',
+            ]);
+            // Act
+            const hasBackgroundTask = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(hasBackgroundTask).toBe(true);
+        });
+        it('should detect "(running)" case-insensitively', () => {
+            // Arrange
+            terminal = createMockTerminal(['Some output', 'command name (RUNNING)']);
+            // Act
+            const hasBackgroundTask = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(hasBackgroundTask).toBe(true);
+        });
+    });
 });

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

@@ -2,4 +2,5 @@ import { SessionState, Terminal } from '../../types/index.js';
 import { BaseStateDetector } from './base.js';
 export declare class ClineStateDetector extends BaseStateDetector {
     detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+    detectBackgroundTask(_terminal: Terminal): boolean;
 }

package/dist/services/stateDetector/cline.js

@@ -21,4 +21,7 @@ export class ClineStateDetector extends BaseStateDetector {
         // Otherwise busy - Priority 3
         return 'busy';
     }
+    detectBackgroundTask(_terminal) {
+        return false;
+    }
 }

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

@@ -2,4 +2,5 @@ import { SessionState, Terminal } from '../../types/index.js';
 import { BaseStateDetector } from './base.js';
 export declare class CodexStateDetector extends BaseStateDetector {
     detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+    detectBackgroundTask(_terminal: Terminal): boolean;
 }

package/dist/services/stateDetector/codex.js

@@ -24,4 +24,7 @@ export class CodexStateDetector extends BaseStateDetector {
         // Otherwise idle
         return 'idle';
     }
+    detectBackgroundTask(_terminal) {
+        return false;
+    }
 }

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

@@ -2,4 +2,5 @@ import { SessionState, Terminal } from '../../types/index.js';
 import { BaseStateDetector } from './base.js';
 export declare class CursorStateDetector extends BaseStateDetector {
     detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+    detectBackgroundTask(_terminal: Terminal): boolean;
 }

package/dist/services/stateDetector/cursor.js

@@ -16,4 +16,7 @@ export class CursorStateDetector extends BaseStateDetector {
         // Otherwise idle - Priority 3
         return 'idle';
     }
+    detectBackgroundTask(_terminal) {
+        return false;
+    }
 }

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

@@ -2,4 +2,5 @@ import { SessionState, Terminal } from '../../types/index.js';
 import { BaseStateDetector } from './base.js';
 export declare class GeminiStateDetector extends BaseStateDetector {
     detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+    detectBackgroundTask(_terminal: Terminal): boolean;
 }

package/dist/services/stateDetector/gemini.js

@@ -25,4 +25,7 @@ export class GeminiStateDetector extends BaseStateDetector {
         // Otherwise idle
         return 'idle';
     }
+    detectBackgroundTask(_terminal) {
+        return false;
+    }
 }

package/dist/services/stateDetector/github-copilot.d.ts

@@ -2,4 +2,5 @@ import { SessionState, Terminal } from '../../types/index.js';
 import { BaseStateDetector } from './base.js';
 export declare class GitHubCopilotStateDetector extends BaseStateDetector {
     detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+    detectBackgroundTask(_terminal: Terminal): boolean;
 }

package/dist/services/stateDetector/github-copilot.js

@@ -18,4 +18,7 @@ export class GitHubCopilotStateDetector extends BaseStateDetector {
         // Otherwise idle as priority 4
         return 'idle';
     }
+    detectBackgroundTask(_terminal) {
+        return false;
+    }
 }

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

@@ -2,4 +2,5 @@ import { SessionState, Terminal } from '../../types/index.js';
 import { BaseStateDetector } from './base.js';
 export declare class OpenCodeStateDetector extends BaseStateDetector {
     detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+    detectBackgroundTask(_terminal: Terminal): boolean;
 }

package/dist/services/stateDetector/opencode.js

@@ -14,4 +14,7 @@ export class OpenCodeStateDetector extends BaseStateDetector {
         // Otherwise idle
         return 'idle';
     }
+    detectBackgroundTask(_terminal) {
+        return false;
+    }
 }

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

@@ -1,4 +1,5 @@
 import { SessionState, Terminal } from '../../types/index.js';
 export interface StateDetector {
     detectState(terminal: Terminal, currentState: SessionState): SessionState;
+    detectBackgroundTask(terminal: Terminal): boolean;
 }

package/dist/types/index.d.ts

@@ -2,6 +2,7 @@ import type { IPty } from '../services/bunTerminal.js';
 import type pkg from '@xterm/headless';
 import { GitStatus } from '../utils/gitStatus.js';
 import { Mutex, SessionStateData } from '../utils/mutex.js';
+import type { StateDetector } from '../services/stateDetector/types.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' | 'opencode';
@@ -33,6 +34,11 @@ export interface Session {
      * Contains: state, pendingState, pendingStateStart, autoApprovalFailed, autoApprovalReason, autoApprovalAbortController
      */
     stateMutex: Mutex<SessionStateData>;
+    /**
+     * State detector instance for this session.
+     * Created once during session initialization based on detectionStrategy.
+     */
+    stateDetector: StateDetector;
 }
 export interface AutoApprovalResponse {
     needsPermission: boolean;

package/dist/utils/hookExecutor.test.js

@@ -8,6 +8,7 @@ import { configurationManager } from '../services/configurationManager.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { GitError } from '../types/errors.js';
 import { Mutex, createInitialSessionStateData } from './mutex.js';
+import { createStateDetector } from '../services/stateDetector/index.js';
 // Mock the configurationManager
 vi.mock('../services/configurationManager.js', () => ({
     configurationManager: {
@@ -275,6 +276,7 @@ describe('hookExecutor Integration Tests', () => {
                 lastActivity: new Date(),
                 isActive: true,
                 stateMutex: new Mutex(createInitialSessionStateData()),
+                stateDetector: createStateDetector('claude'),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(function () {
@@ -329,6 +331,7 @@ describe('hookExecutor Integration Tests', () => {
                 lastActivity: new Date(),
                 isActive: true,
                 stateMutex: new Mutex(createInitialSessionStateData()),
+                stateDetector: createStateDetector('claude'),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(function () {
@@ -381,6 +384,7 @@ describe('hookExecutor Integration Tests', () => {
                 lastActivity: new Date(),
                 isActive: true,
                 stateMutex: new Mutex(createInitialSessionStateData()),
+                stateDetector: createStateDetector('claude'),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(function () {
@@ -435,6 +439,7 @@ describe('hookExecutor Integration Tests', () => {
                 lastActivity: new Date(),
                 isActive: true,
                 stateMutex: new Mutex(createInitialSessionStateData()),
+                stateDetector: createStateDetector('claude'),
             };
             // Mock WorktreeService to fail with GitError
             vi.mocked(WorktreeService).mockImplementation(function () {

package/dist/utils/mutex.d.ts

@@ -47,6 +47,7 @@ export interface SessionStateData {
     autoApprovalFailed: boolean;
     autoApprovalReason: string | undefined;
     autoApprovalAbortController: AbortController | undefined;
+    hasBackgroundTask: boolean;
 }
 /**
  * Create initial session state data with default values.

package/dist/utils/mutex.js

@@ -100,5 +100,6 @@ export function createInitialSessionStateData() {
         autoApprovalFailed: false,
         autoApprovalReason: undefined,
         autoApprovalAbortController: undefined,
+        hasBackgroundTask: false,
     };
 }

package/dist/utils/worktreeUtils.js

@@ -71,8 +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.stateMutex.getSnapshot().state)}]`
+        const stateData = session?.stateMutex.getSnapshot();
+        const status = stateData
+            ? ` [${getStatusDisplay(stateData.state, stateData.hasBackgroundTask)}]`
             : '';
         const fullBranchName = wt.branch
             ? wt.branch.replace('refs/heads/', '')

package/dist/utils/worktreeUtils.test.js

@@ -2,6 +2,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';
+import { createStateDetector } from '../services/stateDetector/index.js';
 // Mock child_process module
 vi.mock('child_process');
 describe('generateWorktreeDirectory', () => {
@@ -137,6 +138,7 @@ describe('prepareWorktreeItems', () => {
             ...createInitialSessionStateData(),
             state: 'idle',
         }),
+        stateDetector: createStateDetector('claude'),
     };
     it('should prepare basic worktree without git status', () => {
         const items = prepareWorktreeItems([mockWorktree], []);

package/package.json

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