ccmanager 3.4.0 → 3.5.1

package/dist/services/sessionManager.js

@@ -3,16 +3,17 @@ import { EventEmitter } from 'events';
 import pkg from '@xterm/headless';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { configurationManager } from './configurationManager.js';
+import { configReader } from './config/configReader.js';
+import { setWorktreeLastOpened } from './worktreeService.js';
 import { executeStatusHook } from '../utils/hookExecutor.js';
 import { createStateDetector } from './stateDetector/index.js';
 import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
-import { Effect } from 'effect';
+import { Effect, Either } from 'effect';
 import { ProcessError, ConfigError } from '../types/errors.js';
 import { autoApprovalVerifier } from './autoApprovalVerifier.js';
 import { logger } from '../utils/logger.js';
 import { Mutex, createInitialSessionStateData } from '../utils/mutex.js';
-import { STATUS_TAGS } from '../constants/statusIcons.js';
+import { getBackgroundTaskTag } from '../constants/statusIcons.js';
 import { getTerminalScreenContent } from '../utils/screenCapture.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
@@ -33,7 +34,7 @@ export class SessionManager extends EventEmitter {
         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() &&
+            configReader.isAutoApprovalEnabled() &&
             !stateData.autoApprovalFailed) {
             return 'pending_auto_approval';
         }
@@ -188,7 +189,7 @@ export class SessionManager extends EventEmitter {
             logLevel: 'off',
         });
     }
-    async createSessionInternal(worktreePath, ptyProcess, commandConfig, options = {}) {
+    async createSessionInternal(worktreePath, ptyProcess, options = {}) {
         const id = this.createSessionId();
         const terminal = this.createTerminal();
         const detectionStrategy = options.detectionStrategy ?? 'claude';
@@ -204,7 +205,6 @@ export class SessionManager extends EventEmitter {
             terminal,
             stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
-            commandConfig,
             detectionStrategy,
             devcontainerConfig: options.devcontainerConfig ?? undefined,
             stateMutex: new Mutex(createInitialSessionStateData()),
@@ -214,7 +214,7 @@ export class SessionManager extends EventEmitter {
         this.setupBackgroundHandler(session);
         this.sessions.set(worktreePath, session);
         // Record the timestamp when this worktree was opened
-        configurationManager.setWorktreeLastOpened(worktreePath, Date.now());
+        setWorktreeLastOpened(worktreePath, Date.now());
         this.emit('sessionCreated', session);
         return session;
     }
@@ -244,12 +244,12 @@ export class SessionManager extends EventEmitter {
                 if (existing) {
                     return existing;
                 }
-                // Get preset configuration
+                // Get preset configuration using Either-based lookup
                 let preset = presetId
-                    ? configurationManager.getPresetById(presetId)
+                    ? Either.getOrElse(configReader.getPresetByIdEffect(presetId), () => null)
                     : null;
                 if (!preset) {
-                    preset = configurationManager.getDefaultPreset();
+                    preset = configReader.getDefaultPreset();
                 }
                 // Validate preset exists
                 if (!preset) {
@@ -263,14 +263,9 @@ export class SessionManager extends EventEmitter {
                 }
                 const command = preset.command;
                 const args = preset.args || [];
-                const commandConfig = {
-                    command: preset.command,
-                    args: preset.args,
-                    fallbackArgs: preset.fallbackArgs,
-                };
                 // Spawn the process - fallback will be handled by setupExitHandler
                 const ptyProcess = await this.spawn(command, args, worktreePath);
-                return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
+                return this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
                     detectionStrategy: preset.detectionStrategy,
                 });
@@ -329,8 +324,6 @@ export class SessionManager extends EventEmitter {
             if (e.exitCode === 1 && !e.signal && session.isPrimaryCommand) {
                 try {
                     let fallbackProcess;
-                    // Use fallback args if available, otherwise use empty args
-                    const fallbackArgs = session.commandConfig?.fallbackArgs || [];
                     // Check if we're in a devcontainer session
                     if (session.devcontainerConfig) {
                         // Parse the exec command to extract arguments
@@ -338,17 +331,12 @@ export class SessionManager extends EventEmitter {
                         const devcontainerCmd = execParts[0] || 'devcontainer';
                         const execArgs = execParts.slice(1);
                         // Build fallback command for devcontainer
-                        const fallbackFullArgs = [
-                            ...execArgs,
-                            '--',
-                            session.commandConfig?.command || 'claude',
-                            ...fallbackArgs,
-                        ];
+                        const fallbackFullArgs = [...execArgs, '--', 'claude'];
                         fallbackProcess = await this.spawn(devcontainerCmd, fallbackFullArgs, session.worktreePath);
                     }
                     else {
                         // Regular fallback without devcontainer
-                        fallbackProcess = await this.spawn(session.commandConfig?.command || 'claude', fallbackArgs, session.worktreePath);
+                        fallbackProcess = await this.spawn('claude', [], session.worktreePath);
                     }
                     // Replace the process
                     session.process = fallbackProcess;
@@ -430,12 +418,12 @@ 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) {
+            // Detect and update background task count
+            const backgroundTaskCount = this.detectBackgroundTask(session);
+            if (currentStateData.backgroundTaskCount !== backgroundTaskCount) {
                 void session.stateMutex.update(data => ({
                     ...data,
-                    hasBackgroundTask,
+                    backgroundTaskCount,
                 }));
             }
         }, STATE_CHECK_INTERVAL_MS);
@@ -466,7 +454,7 @@ export class SessionManager extends EventEmitter {
             session.isActive = active;
             // If becoming active, record the timestamp when this worktree was opened
             if (active) {
-                configurationManager.setWorktreeLastOpened(worktreePath, Date.now());
+                setWorktreeLastOpened(worktreePath, Date.now());
                 // Emit a restore event with the output history if available
                 if (session.outputHistory.length > 0) {
                     this.emit('sessionRestore', session);
@@ -620,12 +608,12 @@ export class SessionManager extends EventEmitter {
                         message: `Failed to start devcontainer: ${error instanceof Error ? error.message : String(error)}`,
                     });
                 }
-                // Get preset configuration
+                // Get preset configuration using Either-based lookup
                 let preset = presetId
-                    ? configurationManager.getPresetById(presetId)
+                    ? Either.getOrElse(configReader.getPresetByIdEffect(presetId), () => null)
                     : null;
                 if (!preset) {
-                    preset = configurationManager.getDefaultPreset();
+                    preset = configReader.getDefaultPreset();
                 }
                 // Validate preset exists
                 if (!preset) {
@@ -650,12 +638,7 @@ export class SessionManager extends EventEmitter {
                 ];
                 // Spawn the process within devcontainer
                 const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath);
-                const commandConfig = {
-                    command: preset.command,
-                    args: preset.args,
-                    fallbackArgs: preset.fallbackArgs,
-                };
-                return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
+                return this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
                     detectionStrategy: preset.detectionStrategy,
                     devcontainerConfig,
@@ -707,9 +690,7 @@ export class SessionManager extends EventEmitter {
                     counts.pending_auto_approval++;
                     break;
             }
-            if (stateData.hasBackgroundTask) {
-                counts.backgroundTasks++;
-            }
+            counts.backgroundTasks += stateData.backgroundTaskCount;
         });
         return counts;
     }
@@ -730,7 +711,8 @@ export class SessionManager extends EventEmitter {
         if (parts.length === 0) {
             return '';
         }
-        const bgTag = counts.backgroundTasks > 0 ? ` ${STATUS_TAGS.BACKGROUND_TASK}` : '';
-        return ` (${parts.join(' / ')}${bgTag})`;
+        const bgTag = getBackgroundTaskTag(counts.backgroundTasks);
+        const bgSuffix = bgTag ? ` ${bgTag}` : '';
+        return ` (${parts.join(' / ')}${bgSuffix})`;
     }
 }

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

@@ -1,4 +1,5 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { Either } from 'effect';
 import { SessionManager } from './sessionManager.js';
 import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
@@ -8,8 +9,8 @@ vi.mock('./bunTerminal.js', () => ({
         return null;
     }),
 }));
-vi.mock('./configurationManager.js', () => ({
-    configurationManager: {
+vi.mock('./config/configReader.js', () => ({
+    configReader: {
         getConfig: vi.fn().mockReturnValue({
             commands: [
                 {
@@ -21,12 +22,12 @@ vi.mock('./configurationManager.js', () => ({
             ],
             defaultCommandId: 'test',
         }),
-        getPresetById: vi.fn().mockReturnValue({
+        getPresetByIdEffect: vi.fn().mockReturnValue(Either.right({
             id: 'test',
             name: 'Test',
             command: 'test',
             args: [],
-        }),
+        })),
         getDefaultPreset: vi.fn().mockReturnValue({
             id: 'test',
             name: 'Test',

package/dist/services/sessionManager.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { Effect } from 'effect';
+import { Effect, Either } from 'effect';
+import { ValidationError } from '../types/errors.js';
 import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
 import { exec } from 'child_process';
@@ -19,12 +20,11 @@ vi.mock('child_process', () => ({
     }),
 }));
 // Mock configuration manager
-vi.mock('./configurationManager.js', () => ({
-    configurationManager: {
-        getCommandConfig: vi.fn(),
+vi.mock('./config/configReader.js', () => ({
+    configReader: {
         getStatusHooks: vi.fn(() => ({})),
         getDefaultPreset: vi.fn(),
-        getPresetById: vi.fn(),
+        getPresetByIdEffect: vi.fn(),
         setWorktreeLastOpened: vi.fn(),
         getWorktreeLastOpenedTime: vi.fn(),
         getWorktreeLastOpened: vi.fn(() => ({})),
@@ -57,6 +57,9 @@ vi.mock('./worktreeService.js', () => ({
     WorktreeService: vi.fn(function () {
         return {};
     }),
+    setWorktreeLastOpened: vi.fn(),
+    getWorktreeLastOpened: vi.fn(() => ({})),
+    getWorktreeLastOpenedTime: vi.fn(),
 }));
 // Create a mock IPty class
 class MockPty extends EventEmitter {
@@ -102,14 +105,14 @@ describe('SessionManager', () => {
     let sessionManager;
     let mockPty;
     let SessionManager;
-    let configurationManager;
+    let configReader;
     beforeEach(async () => {
         vi.clearAllMocks();
         // Dynamically import after mocks are set up
         const sessionManagerModule = await import('./sessionManager.js');
-        const configManagerModule = await import('./configurationManager.js');
+        const configManagerModule = await import('./config/configReader.js');
         SessionManager = sessionManagerModule.SessionManager;
-        configurationManager = configManagerModule.configurationManager;
+        configReader = configManagerModule.configReader;
         sessionManager = new SessionManager();
         mockPty = new MockPty();
     });
@@ -119,7 +122,7 @@ describe('SessionManager', () => {
     describe('createSessionWithPresetEffect', () => {
         it('should use default preset when no preset ID specified', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -140,19 +143,19 @@ describe('SessionManager', () => {
         });
         it('should use specific preset when ID provided', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getPresetById).mockReturnValue({
+            vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.right({
                 id: '2',
                 name: 'Development',
                 command: 'claude',
                 args: ['--resume', '--dev'],
                 fallbackArgs: ['--no-mcp'],
-            });
+            }));
             // Setup spawn mock
             vi.mocked(spawn).mockReturnValue(mockPty);
             // Create session with specific preset
             await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree', '2'));
-            // Verify getPresetById was called with correct ID
-            expect(configurationManager.getPresetById).toHaveBeenCalledWith('2');
+            // Verify getPresetByIdEffect was called with correct ID
+            expect(configReader.getPresetByIdEffect).toHaveBeenCalledWith('2');
             // Verify spawn was called with preset config
             expect(spawn).toHaveBeenCalledWith('claude', ['--resume', '--dev'], {
                 name: 'xterm-256color',
@@ -164,8 +167,12 @@ describe('SessionManager', () => {
         });
         it('should fall back to default preset if specified preset not found', async () => {
             // Setup mocks
-            vi.mocked(configurationManager.getPresetById).mockReturnValue(undefined);
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.left(new ValidationError({
+                field: 'presetId',
+                constraint: 'Preset not found',
+                receivedValue: 'invalid',
+            })));
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -175,12 +182,12 @@ describe('SessionManager', () => {
             // Create session with non-existent preset
             await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree', 'invalid'));
             // Verify fallback to default preset
-            expect(configurationManager.getDefaultPreset).toHaveBeenCalled();
+            expect(configReader.getDefaultPreset).toHaveBeenCalled();
             expect(spawn).toHaveBeenCalledWith('claude', [], expect.any(Object));
         });
         it('should throw error when spawn fails with preset', async () => {
             // Setup mock preset with fallback
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -199,7 +206,7 @@ describe('SessionManager', () => {
         });
         it('should return existing session if already created', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -216,7 +223,7 @@ describe('SessionManager', () => {
         });
         it('should throw error when spawn fails with fallback args', async () => {
             // Setup mock preset with fallback
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'nonexistent-command',
@@ -230,14 +237,13 @@ describe('SessionManager', () => {
             // Expect createSessionWithPresetEffect to throw the original error
             await expect(Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'))).rejects.toThrow('Command not found');
         });
-        it('should use fallback args when main command exits with code 1', async () => {
-            // Setup mock preset with fallback
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+        it('should fallback to default command when main command exits with code 1', async () => {
+            // Setup mock preset with args
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
                 args: ['--invalid-flag'],
-                fallbackArgs: ['--resume'],
             });
             // First spawn attempt - will exit with code 1
             const firstMockPty = new MockPty();
@@ -255,16 +261,16 @@ describe('SessionManager', () => {
             firstMockPty.emit('exit', { exitCode: 1 });
             // Wait for fallback to occur
             await new Promise(resolve => setTimeout(resolve, 50));
-            // Verify fallback spawn was called
+            // Verify fallback spawn was called (with no args since commandConfig was removed)
             expect(spawn).toHaveBeenCalledTimes(2);
-            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--resume'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', [], expect.objectContaining({ cwd: '/test/worktree' }));
             // Verify session process was replaced
             expect(session.process).toBe(secondMockPty);
             expect(session.isPrimaryCommand).toBe(false);
         });
         it('should not use fallback if main command succeeds', async () => {
             // Setup mock preset with fallback
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -283,7 +289,7 @@ describe('SessionManager', () => {
         });
         it('should use empty args as fallback when no fallback args specified', async () => {
             // Setup mock preset without fallback args
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -316,7 +322,7 @@ describe('SessionManager', () => {
         });
         it('should handle custom command configuration', async () => {
             // Setup mock preset with custom command
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'my-custom-claude',
@@ -333,7 +339,7 @@ describe('SessionManager', () => {
         });
         it('should throw error when spawn fails and no fallback configured', async () => {
             // Setup mock preset without fallback
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -350,7 +356,7 @@ describe('SessionManager', () => {
     describe('session lifecycle', () => {
         it('should destroy session and clean up resources', async () => {
             // Setup
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -365,7 +371,7 @@ describe('SessionManager', () => {
         });
         it('should handle session exit event', async () => {
             // Setup
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -411,7 +417,7 @@ describe('SessionManager', () => {
         });
         it('should execute devcontainer up command before creating session', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -431,12 +437,12 @@ describe('SessionManager', () => {
         });
         it('should use specific preset when ID provided', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getPresetById).mockReturnValue({
+            vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.right({
                 id: '2',
                 name: 'Development',
                 command: 'claude',
                 args: ['--resume', '--dev'],
-            });
+            }));
             // Setup spawn mock
             vi.mocked(spawn).mockReturnValue(mockPty);
             // Create session with devcontainer and specific preset
@@ -446,7 +452,7 @@ describe('SessionManager', () => {
             };
             await Effect.runPromise(sessionManager.createSessionWithDevcontainerEffect('/test/worktree', devcontainerConfig, '2'));
             // Verify correct preset was used
-            expect(configurationManager.getPresetById).toHaveBeenCalledWith('2');
+            expect(configReader.getPresetByIdEffect).toHaveBeenCalledWith('2');
             expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--', 'claude', '--resume', '--dev'], expect.any(Object));
         });
         it('should throw error when devcontainer up fails', async () => {
@@ -462,7 +468,7 @@ describe('SessionManager', () => {
         });
         it('should return existing session if already created', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -483,7 +489,7 @@ describe('SessionManager', () => {
         });
         it('should handle complex exec commands with multiple arguments', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -514,7 +520,7 @@ describe('SessionManager', () => {
             // Create a new session manager and reset mocks
             vi.clearAllMocks();
             sessionManager = new SessionManager();
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -605,12 +611,12 @@ describe('SessionManager', () => {
                 }
                 return {};
             });
-            vi.mocked(configurationManager.getPresetById).mockReturnValue({
+            vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.right({
                 id: 'claude-with-args',
                 name: 'Claude with Args',
                 command: 'claude',
                 args: ['-m', 'claude-3-opus'],
-            });
+            }));
             await Effect.runPromise(sessionManager.createSessionWithDevcontainerEffect('/test/worktree', {
                 upCommand: 'devcontainer up --workspace-folder .',
                 execCommand: 'devcontainer exec --workspace-folder .',
@@ -638,7 +644,7 @@ describe('SessionManager', () => {
                 return {};
             });
             // Setup preset without fallback args
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -671,7 +677,7 @@ describe('SessionManager', () => {
             expect(session.process).toBe(secondMockPty);
             expect(session.isPrimaryCommand).toBe(false);
         });
-        it('should use fallback args in devcontainer when primary command exits with code 1', async () => {
+        it('should fallback to default command in devcontainer when primary command exits with code 1', async () => {
             const mockExec = vi.mocked(exec);
             mockExec.mockImplementation((cmd, options, callback) => {
                 if (typeof options === 'function') {
@@ -683,13 +689,12 @@ describe('SessionManager', () => {
                 }
                 return {};
             });
-            // Setup preset with fallback
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            // Setup preset with args
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
                 args: ['--bad-flag'],
-                fallbackArgs: ['--good-flag'],
             });
             // First spawn attempt - will exit with code 1
             const firstMockPty = new MockPty();
@@ -709,9 +714,9 @@ describe('SessionManager', () => {
             firstMockPty.emit('exit', { exitCode: 1 });
             // Wait for fallback to occur
             await new Promise(resolve => setTimeout(resolve, 50));
-            // Verify fallback spawn was called
+            // Verify fallback spawn was called (with no args since commandConfig was removed)
             expect(spawn).toHaveBeenCalledTimes(2);
-            expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude', '--good-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude'], expect.objectContaining({ cwd: '/test/worktree' }));
             // Verify session process was replaced
             expect(session.process).toBe(secondMockPty);
             expect(session.isPrimaryCommand).toBe(false);
@@ -720,10 +725,10 @@ describe('SessionManager', () => {
     describe('static methods', () => {
         describe('getSessionCounts', () => {
             // Helper to create mock session with stateMutex
-            const createMockSession = (id, state, hasBackgroundTask = false) => ({
+            const createMockSession = (id, state, backgroundTaskCount = 0) => ({
                 id,
                 stateMutex: {
-                    getSnapshot: () => ({ state, hasBackgroundTask }),
+                    getSnapshot: () => ({ state, backgroundTaskCount }),
                 },
             });
             it('should count sessions by state', () => {
@@ -759,6 +764,16 @@ describe('SessionManager', () => {
                 expect(counts.waiting_input).toBe(0);
                 expect(counts.total).toBe(3);
             });
+            it('should sum background task counts across sessions', () => {
+                const sessions = [
+                    createMockSession('1', 'idle', 0),
+                    createMockSession('2', 'busy', 2),
+                    createMockSession('3', 'busy', 3),
+                    createMockSession('4', 'waiting_input', 1),
+                ];
+                const counts = SessionManager.getSessionCounts(sessions);
+                expect(counts.backgroundTasks).toBe(6);
+            });
         });
         describe('formatSessionCounts', () => {
             it('should format counts with all states', () => {
@@ -809,7 +824,7 @@ describe('SessionManager', () => {
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).toBe('');
             });
-            it('should append [BG] tag when background tasks exist', () => {
+            it('should append [BG] tag when backgroundTasks is 1', () => {
                 const counts = {
                     idle: 1,
                     busy: 1,
@@ -822,6 +837,32 @@ describe('SessionManager', () => {
                 expect(formatted).toContain('[BG]');
                 expect(formatted).toBe(' (1 Idle / 1 Busy \x1b[2m[BG]\x1b[0m)');
             });
+            it('should append [BG:N] tag when backgroundTasks is 2+', () => {
+                const counts = {
+                    idle: 1,
+                    busy: 1,
+                    waiting_input: 0,
+                    pending_auto_approval: 0,
+                    total: 2,
+                    backgroundTasks: 5,
+                };
+                const formatted = SessionManager.formatSessionCounts(counts);
+                expect(formatted).toContain('[BG:5]');
+                expect(formatted).toBe(' (1 Idle / 1 Busy \x1b[2m[BG:5]\x1b[0m)');
+            });
+            it('should not append BG tag when backgroundTasks is 0', () => {
+                const counts = {
+                    idle: 1,
+                    busy: 1,
+                    waiting_input: 0,
+                    pending_auto_approval: 0,
+                    total: 2,
+                    backgroundTasks: 0,
+                };
+                const formatted = SessionManager.formatSessionCounts(counts);
+                expect(formatted).not.toContain('[BG');
+                expect(formatted).toBe(' (1 Idle / 1 Busy)');
+            });
         });
     });
 });

package/dist/services/shortcutManager.d.ts

@@ -5,7 +5,6 @@ export declare class ShortcutManager {
     constructor();
     private validateShortcut;
     private isReservedKey;
-    saveShortcuts(shortcuts: ShortcutConfig): boolean;
     getShortcuts(): ShortcutConfig;
     private getRawShortcutCodes;
     matchesShortcut(shortcutName: keyof ShortcutConfig, input: string, key: Key): boolean;