ccmanager 3.7.4 → 3.8.0

package/README.md

@@ -162,6 +162,16 @@ CCManager supports configuring the command and arguments used to run Claude Code
 
 For detailed configuration options and examples, see [docs/command-config.md](docs/command-config.md).
 
+## Claude Code Teammate Mode
+
+When running the `claude` command with the default (`claude`) detection strategy, CCManager automatically appends `--teammate-mode in-process` to the CLI arguments. This prevents conflicts between Claude Code's agent teams feature and ccmanager's PTY-based session management.
+
+- **Automatic**: No configuration needed. CCManager injects the flag for all `claude` command sessions.
+- **Override**: If you explicitly specify `--teammate-mode` in your preset args, your value takes priority.
+- **Non-claude commands**: Other AI assistants (Gemini, Codex, etc.) are not affected.
+
+Setting `"teammateMode": "in-process"` in Claude Code's `settings.json` alone is not sufficient when running inside a tmux-like environment, which is why CCManager controls this via the CLI argument.
+
 
 ## Session Data Copying
 

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

@@ -126,6 +126,7 @@ describe('Menu - Recent Projects', () => {
             pending_auto_approval: 0,
             total: 0,
             backgroundTasks: 0,
+            teamMembers: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
         const { lastFrame, rerender } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
@@ -159,6 +160,7 @@ describe('Menu - Recent Projects', () => {
             pending_auto_approval: 0,
             total: 0,
             backgroundTasks: 0,
+            teamMembers: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
         const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));

package/dist/components/Menu.test.js

@@ -277,6 +277,7 @@ describe('Menu component rendering', () => {
             pending_auto_approval: 0,
             total: 0,
             backgroundTasks: 0,
+            teamMembers: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
         const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true, version: "test" }));
@@ -319,6 +320,7 @@ describe('Menu component rendering', () => {
             pending_auto_approval: 0,
             total: 0,
             backgroundTasks: 0,
+            teamMembers: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
         const { lastFrame } = render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: onSelectWorktree, onSelectRecentProject: onSelectRecentProject, multiProject: true, version: "test" }));

package/dist/constants/statusIcons.d.ts

@@ -14,6 +14,7 @@ export declare const STATUS_TAGS: {
     readonly BACKGROUND_TASK: "\u001B[2m[BG]\u001B[0m";
 };
 export declare const getBackgroundTaskTag: (count: number) => string;
+export declare const getTeamMemberTag: (count: number) => string;
 export declare const MENU_ICONS: {
     readonly NEW_WORKTREE: "⊕";
     readonly MERGE_WORKTREE: "⇄";
@@ -21,4 +22,4 @@ export declare const MENU_ICONS: {
     readonly CONFIGURE_SHORTCUTS: "⌨";
     readonly EXIT: "⏻";
 };
-export declare const getStatusDisplay: (status: SessionState, backgroundTaskCount?: number) => string;
+export declare const getStatusDisplay: (status: SessionState, backgroundTaskCount?: number, teamMemberCount?: number) => string;

package/dist/constants/statusIcons.js

@@ -22,6 +22,11 @@ export const getBackgroundTaskTag = (count) => {
     // count >= 2: show [BG:N]
     return `\x1b[2m[BG:${count}]\x1b[0m`;
 };
+export const getTeamMemberTag = (count) => {
+    if (count <= 0)
+        return '';
+    return `\x1b[2m[Team:${count}]\x1b[0m`;
+};
 export const MENU_ICONS = {
     NEW_WORKTREE: '⊕',
     MERGE_WORKTREE: '⇄',
@@ -41,8 +46,10 @@ const getBaseStatusDisplay = (status) => {
             return `${STATUS_ICONS.IDLE} ${STATUS_LABELS.IDLE}`;
     }
 };
-export const getStatusDisplay = (status, backgroundTaskCount = 0) => {
+export const getStatusDisplay = (status, backgroundTaskCount = 0, teamMemberCount = 0) => {
     const display = getBaseStatusDisplay(status);
     const bgTag = getBackgroundTaskTag(backgroundTaskCount);
-    return bgTag ? `${display} ${bgTag}` : display;
+    const teamTag = getTeamMemberTag(teamMemberCount);
+    const suffix = [bgTag, teamTag].filter(Boolean).join(' ');
+    return suffix ? `${display} ${suffix}` : display;
 };

package/dist/constants/statusIcons.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { getStatusDisplay, getBackgroundTaskTag, STATUS_ICONS, STATUS_LABELS, STATUS_TAGS, } from './statusIcons.js';
+import { getStatusDisplay, getBackgroundTaskTag, getTeamMemberTag, STATUS_ICONS, STATUS_LABELS, STATUS_TAGS, } from './statusIcons.js';
 describe('getStatusDisplay', () => {
     it('should return busy display for busy state', () => {
         const result = getStatusDisplay('busy');
@@ -70,3 +70,35 @@ describe('getBackgroundTaskTag', () => {
         expect(result).toBe('\x1b[2m[BG:10]\x1b[0m');
     });
 });
+describe('getTeamMemberTag', () => {
+    it('should return empty string when count is 0', () => {
+        expect(getTeamMemberTag(0)).toBe('');
+    });
+    it('should return empty string when count is negative', () => {
+        expect(getTeamMemberTag(-1)).toBe('');
+        expect(getTeamMemberTag(-100)).toBe('');
+    });
+    it('should return [Team:1] when count is 1', () => {
+        expect(getTeamMemberTag(1)).toBe('\x1b[2m[Team:1]\x1b[0m');
+    });
+    it('should return [Team:4] when count is 4', () => {
+        expect(getTeamMemberTag(4)).toBe('\x1b[2m[Team:4]\x1b[0m');
+    });
+    it('should return [Team:10] when count is 10', () => {
+        expect(getTeamMemberTag(10)).toBe('\x1b[2m[Team:10]\x1b[0m');
+    });
+});
+describe('getStatusDisplay with team members', () => {
+    it('should append [Team:4] badge when teamMemberCount is 4', () => {
+        const result = getStatusDisplay('busy', 0, 4);
+        expect(result).toBe(`${STATUS_ICONS.BUSY} ${STATUS_LABELS.BUSY} \x1b[2m[Team:4]\x1b[0m`);
+    });
+    it('should append both [BG] and [Team:4] badges', () => {
+        const result = getStatusDisplay('busy', 1, 4);
+        expect(result).toBe(`${STATUS_ICONS.BUSY} ${STATUS_LABELS.BUSY} ${STATUS_TAGS.BACKGROUND_TASK} \x1b[2m[Team:4]\x1b[0m`);
+    });
+    it('should not append [Team] badge when teamMemberCount is 0', () => {
+        const result = getStatusDisplay('idle', 0, 0);
+        expect(result).toBe(`${STATUS_ICONS.IDLE} ${STATUS_LABELS.IDLE}`);
+    });
+});

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

@@ -18,6 +18,7 @@ vi.mock('./stateDetector/index.js', () => ({
     createStateDetector: () => ({
         detectState: detectStateMock,
         detectBackgroundTask: () => false,
+        detectTeamMembers: () => 0,
     }),
 }));
 vi.mock('./config/configReader.js', () => ({

package/dist/services/sessionManager.d.ts

@@ -9,6 +9,7 @@ export interface SessionCounts {
     pending_auto_approval: number;
     total: number;
     backgroundTasks: number;
+    teamMembers: number;
 }
 export declare class SessionManager extends EventEmitter implements ISessionManager {
     sessions: Map<string, Session>;
@@ -18,6 +19,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private spawn;
     detectTerminalState(session: Session): SessionState;
     detectBackgroundTask(session: Session): number;
+    detectTeamMembers(session: Session): number;
     private getTerminalContent;
     private handleAutoApproval;
     private cancelAutoApprovalVerification;

package/dist/services/sessionManager.js

@@ -13,8 +13,9 @@ 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 { getBackgroundTaskTag } from '../constants/statusIcons.js';
+import { getBackgroundTaskTag, getTeamMemberTag, } from '../constants/statusIcons.js';
 import { getTerminalScreenContent } from '../utils/screenCapture.js';
+import { injectTeammateMode } from '../utils/commandArgs.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
 const TERMINAL_CONTENT_MAX_LINES = 300;
@@ -48,6 +49,9 @@ export class SessionManager extends EventEmitter {
     detectBackgroundTask(session) {
         return session.stateDetector.detectBackgroundTask(session.terminal);
     }
+    detectTeamMembers(session) {
+        return session.stateDetector.detectTeamMembers(session.terminal);
+    }
     getTerminalContent(session) {
         // Use the new screen capture utility that correctly handles
         // both normal and alternate screen buffers
@@ -249,7 +253,7 @@ export class SessionManager extends EventEmitter {
                     });
                 }
                 const command = preset.command;
-                const args = preset.args || [];
+                const args = injectTeammateMode(preset.command, preset.args || [], preset.detectionStrategy);
                 // Spawn the process - fallback will be handled by setupExitHandler
                 const ptyProcess = await this.spawn(command, args, worktreePath);
                 return this.createSessionInternal(worktreePath, ptyProcess, {
@@ -325,12 +329,19 @@ export class SessionManager extends EventEmitter {
                         const devcontainerCmd = execParts[0] || 'devcontainer';
                         const execArgs = execParts.slice(1);
                         // Build fallback command for devcontainer
-                        const fallbackFullArgs = [...execArgs, '--', 'claude'];
+                        const fallbackClaudeArgs = injectTeammateMode('claude', [], session.detectionStrategy);
+                        const fallbackFullArgs = [
+                            ...execArgs,
+                            '--',
+                            'claude',
+                            ...fallbackClaudeArgs,
+                        ];
                         fallbackProcess = await this.spawn(devcontainerCmd, fallbackFullArgs, session.worktreePath);
                     }
                     else {
                         // Regular fallback without devcontainer
-                        fallbackProcess = await this.spawn('claude', [], session.worktreePath);
+                        const fallbackArgs = injectTeammateMode('claude', [], session.detectionStrategy);
+                        fallbackProcess = await this.spawn('claude', fallbackArgs, session.worktreePath);
                     }
                     // Replace the process
                     session.process = fallbackProcess;
@@ -420,6 +431,14 @@ export class SessionManager extends EventEmitter {
                     backgroundTaskCount,
                 }));
             }
+            // Detect and update team member count
+            const teamMemberCount = this.detectTeamMembers(session);
+            if (currentStateData.teamMemberCount !== teamMemberCount) {
+                void session.stateMutex.update(data => ({
+                    ...data,
+                    teamMemberCount,
+                }));
+            }
         }, STATE_CHECK_INTERVAL_MS);
         // Setup exit handler
         this.setupExitHandler(session);
@@ -638,12 +657,8 @@ export class SessionManager extends EventEmitter {
                 const devcontainerCmd = execParts[0] || 'devcontainer';
                 const execArgs = execParts.slice(1);
                 // Build the full command: devcontainer exec [args] -- [preset command] [preset args]
-                const fullArgs = [
-                    ...execArgs,
-                    '--',
-                    preset.command,
-                    ...(preset.args || []),
-                ];
+                const presetArgs = injectTeammateMode(preset.command, preset.args || [], preset.detectionStrategy);
+                const fullArgs = [...execArgs, '--', preset.command, ...presetArgs];
                 // Spawn the process within devcontainer
                 const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath);
                 return this.createSessionInternal(worktreePath, ptyProcess, {
@@ -681,6 +696,7 @@ export class SessionManager extends EventEmitter {
             pending_auto_approval: 0,
             total: sessions.length,
             backgroundTasks: 0,
+            teamMembers: 0,
         };
         sessions.forEach(session => {
             const stateData = session.stateMutex.getSnapshot();
@@ -699,6 +715,7 @@ export class SessionManager extends EventEmitter {
                     break;
             }
             counts.backgroundTasks += stateData.backgroundTaskCount;
+            counts.teamMembers += stateData.teamMemberCount;
         });
         return counts;
     }
@@ -721,6 +738,8 @@ export class SessionManager extends EventEmitter {
         }
         const bgTag = getBackgroundTaskTag(counts.backgroundTasks);
         const bgSuffix = bgTag ? ` ${bgTag}` : '';
-        return ` (${parts.join(' / ')}${bgSuffix})`;
+        const teamTag = getTeamMemberTag(counts.teamMembers);
+        const teamSuffix = teamTag ? ` ${teamTag}` : '';
+        return ` (${parts.join(' / ')}${bgSuffix}${teamSuffix})`;
     }
 }

package/dist/services/sessionManager.test.js

@@ -106,7 +106,7 @@ describe('SessionManager', () => {
             // Create session with preset
             await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
             // Verify spawn was called with preset config
-            expect(spawn).toHaveBeenCalledWith('claude', ['--preset-arg'], {
+            expect(spawn).toHaveBeenCalledWith('claude', ['--preset-arg', '--teammate-mode', 'in-process'], {
                 name: 'xterm-256color',
                 cols: expect.any(Number),
                 rows: expect.any(Number),
@@ -130,7 +130,7 @@ describe('SessionManager', () => {
             // 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'], {
+            expect(spawn).toHaveBeenCalledWith('claude', ['--resume', '--dev', '--teammate-mode', 'in-process'], {
                 name: 'xterm-256color',
                 cols: expect.any(Number),
                 rows: expect.any(Number),
@@ -156,7 +156,7 @@ describe('SessionManager', () => {
             await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree', 'invalid'));
             // Verify fallback to default preset
             expect(configReader.getDefaultPreset).toHaveBeenCalled();
-            expect(spawn).toHaveBeenCalledWith('claude', [], expect.any(Object));
+            expect(spawn).toHaveBeenCalledWith('claude', ['--teammate-mode', 'in-process'], expect.any(Object));
         });
         it('should throw error when spawn fails with preset', async () => {
             // Setup mock preset with fallback
@@ -175,7 +175,7 @@ describe('SessionManager', () => {
             await expect(Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'))).rejects.toThrow('Command failed');
             // Verify only one spawn attempt was made
             expect(spawn).toHaveBeenCalledTimes(1);
-            expect(spawn).toHaveBeenCalledWith('claude', ['--bad-flag'], expect.any(Object));
+            expect(spawn).toHaveBeenCalledWith('claude', ['--bad-flag', '--teammate-mode', 'in-process'], expect.any(Object));
         });
         it('should return existing session if already created', async () => {
             // Setup mock preset
@@ -229,14 +229,14 @@ describe('SessionManager', () => {
             const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
             // Verify initial spawn
             expect(spawn).toHaveBeenCalledTimes(1);
-            expect(spawn).toHaveBeenCalledWith('claude', ['--invalid-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenCalledWith('claude', ['--invalid-flag', '--teammate-mode', 'in-process'], expect.objectContaining({ cwd: '/test/worktree' }));
             // Simulate exit with code 1 on first attempt
             firstMockPty.emit('exit', { exitCode: 1 });
             // Wait for fallback to occur
             await new Promise(resolve => setTimeout(resolve, 50));
             // Verify fallback spawn was called (with no args since commandConfig was removed)
             expect(spawn).toHaveBeenCalledTimes(2);
-            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', [], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--teammate-mode', 'in-process'], expect.objectContaining({ cwd: '/test/worktree' }));
             // Verify session process was replaced
             expect(session.process).toBe(secondMockPty);
             expect(session.isPrimaryCommand).toBe(false);
@@ -258,7 +258,7 @@ describe('SessionManager', () => {
             await new Promise(resolve => setTimeout(resolve, 600));
             // Verify only one spawn attempt
             expect(spawn).toHaveBeenCalledTimes(1);
-            expect(spawn).toHaveBeenCalledWith('claude', ['--resume'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenCalledWith('claude', ['--resume', '--teammate-mode', 'in-process'], expect.objectContaining({ cwd: '/test/worktree' }));
         });
         it('should use empty args as fallback when no fallback args specified', async () => {
             // Setup mock preset without fallback args
@@ -280,15 +280,14 @@ describe('SessionManager', () => {
             const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
             // Verify initial spawn
             expect(spawn).toHaveBeenCalledTimes(1);
-            expect(spawn).toHaveBeenCalledWith('claude', ['--invalid-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenCalledWith('claude', ['--invalid-flag', '--teammate-mode', 'in-process'], expect.objectContaining({ cwd: '/test/worktree' }));
             // Simulate exit with code 1 on first attempt
             firstMockPty.emit('exit', { exitCode: 1 });
             // Wait for fallback to occur
             await new Promise(resolve => setTimeout(resolve, 50));
-            // Verify fallback spawn was called with empty args
+            // Verify fallback spawn was called with teammate-mode args
             expect(spawn).toHaveBeenCalledTimes(2);
-            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', [], // Empty args
-            expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--teammate-mode', 'in-process'], expect.objectContaining({ cwd: '/test/worktree' }));
             // Verify session process was replaced
             expect(session.process).toBe(secondMockPty);
             expect(session.isPrimaryCommand).toBe(false);
@@ -406,7 +405,16 @@ describe('SessionManager', () => {
             await Effect.runPromise(sessionManager.createSessionWithDevcontainerEffect('/test/worktree', devcontainerConfig));
             // Verify spawn was called correctly which proves devcontainer up succeeded
             // Verify spawn was called with devcontainer exec
-            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude', '--resume'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenCalledWith('devcontainer', [
+                'exec',
+                '--workspace-folder',
+                '.',
+                '--',
+                'claude',
+                '--resume',
+                '--teammate-mode',
+                'in-process',
+            ], expect.objectContaining({ cwd: '/test/worktree' }));
         });
         it('should use specific preset when ID provided', async () => {
             // Setup mock preset
@@ -426,7 +434,15 @@ describe('SessionManager', () => {
             await Effect.runPromise(sessionManager.createSessionWithDevcontainerEffect('/test/worktree', devcontainerConfig, '2'));
             // Verify correct preset was used
             expect(configReader.getPresetByIdEffect).toHaveBeenCalledWith('2');
-            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--', 'claude', '--resume', '--dev'], expect.any(Object));
+            expect(spawn).toHaveBeenCalledWith('devcontainer', [
+                'exec',
+                '--',
+                'claude',
+                '--resume',
+                '--dev',
+                '--teammate-mode',
+                'in-process',
+            ], expect.any(Object));
         });
         it('should throw error when devcontainer up fails', async () => {
             // Setup exec to fail
@@ -487,6 +503,8 @@ describe('SessionManager', () => {
                 'claude',
                 '--model',
                 'opus',
+                '--teammate-mode',
+                'in-process',
             ], expect.any(Object));
         });
         it('should spawn process with devcontainer exec command', async () => {
@@ -517,7 +535,15 @@ describe('SessionManager', () => {
                 execCommand: 'devcontainer exec --workspace-folder .',
             }));
             // Should spawn with devcontainer exec command
-            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude'], expect.objectContaining({
+            expect(spawn).toHaveBeenCalledWith('devcontainer', [
+                'exec',
+                '--workspace-folder',
+                '.',
+                '--',
+                'claude',
+                '--teammate-mode',
+                'in-process',
+            ], expect.objectContaining({
                 cwd: '/test/worktree2',
             }));
         });
@@ -570,6 +596,8 @@ describe('SessionManager', () => {
                 'vscode',
                 '--',
                 'claude',
+                '--teammate-mode',
+                'in-process',
             ], expect.any(Object));
         });
         it('should handle preset with args in devcontainer', async () => {
@@ -602,6 +630,8 @@ describe('SessionManager', () => {
                 'claude',
                 '-m',
                 'claude-3-opus',
+                '--teammate-mode',
+                'in-process',
             ], expect.any(Object));
         });
         it('should use empty args as fallback in devcontainer when no fallback args specified', async () => {
@@ -637,15 +667,31 @@ describe('SessionManager', () => {
             }));
             // Verify initial spawn
             expect(spawn).toHaveBeenCalledTimes(1);
-            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude', '--invalid-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenCalledWith('devcontainer', [
+                'exec',
+                '--workspace-folder',
+                '.',
+                '--',
+                'claude',
+                '--invalid-flag',
+                '--teammate-mode',
+                'in-process',
+            ], expect.objectContaining({ cwd: '/test/worktree' }));
             // Simulate exit with code 1 on first attempt
             firstMockPty.emit('exit', { exitCode: 1 });
             // Wait for fallback to occur
             await new Promise(resolve => setTimeout(resolve, 50));
-            // Verify fallback spawn was called with empty args
+            // Verify fallback spawn was called with teammate-mode args
             expect(spawn).toHaveBeenCalledTimes(2);
-            expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude'], // No args after claude
-            expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', [
+                'exec',
+                '--workspace-folder',
+                '.',
+                '--',
+                'claude',
+                '--teammate-mode',
+                'in-process',
+            ], expect.objectContaining({ cwd: '/test/worktree' }));
             // Verify session process was replaced
             expect(session.process).toBe(secondMockPty);
             expect(session.isPrimaryCommand).toBe(false);
@@ -682,14 +728,31 @@ describe('SessionManager', () => {
             }));
             // Verify initial spawn
             expect(spawn).toHaveBeenCalledTimes(1);
-            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude', '--bad-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenCalledWith('devcontainer', [
+                'exec',
+                '--workspace-folder',
+                '.',
+                '--',
+                'claude',
+                '--bad-flag',
+                '--teammate-mode',
+                'in-process',
+            ], expect.objectContaining({ cwd: '/test/worktree' }));
             // Simulate exit with code 1 on first attempt
             firstMockPty.emit('exit', { exitCode: 1 });
             // Wait for fallback to occur
             await new Promise(resolve => setTimeout(resolve, 50));
-            // Verify fallback spawn was called (with no args since commandConfig was removed)
+            // Verify fallback spawn was called with teammate-mode args
             expect(spawn).toHaveBeenCalledTimes(2);
-            expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', [
+                'exec',
+                '--workspace-folder',
+                '.',
+                '--',
+                'claude',
+                '--teammate-mode',
+                'in-process',
+            ], expect.objectContaining({ cwd: '/test/worktree' }));
             // Verify session process was replaced
             expect(session.process).toBe(secondMockPty);
             expect(session.isPrimaryCommand).toBe(false);
@@ -781,10 +844,10 @@ describe('SessionManager', () => {
     describe('static methods', () => {
         describe('getSessionCounts', () => {
             // Helper to create mock session with stateMutex
-            const createMockSession = (id, state, backgroundTaskCount = 0) => ({
+            const createMockSession = (id, state, backgroundTaskCount = 0, teamMemberCount = 0) => ({
                 id,
                 stateMutex: {
-                    getSnapshot: () => ({ state, backgroundTaskCount }),
+                    getSnapshot: () => ({ state, backgroundTaskCount, teamMemberCount }),
                 },
             });
             it('should count sessions by state', () => {
@@ -830,6 +893,15 @@ describe('SessionManager', () => {
                 const counts = SessionManager.getSessionCounts(sessions);
                 expect(counts.backgroundTasks).toBe(6);
             });
+            it('should sum team member counts across sessions', () => {
+                const sessions = [
+                    createMockSession('1', 'idle', 0, 0),
+                    createMockSession('2', 'busy', 0, 4),
+                    createMockSession('3', 'busy', 0, 2),
+                ];
+                const counts = SessionManager.getSessionCounts(sessions);
+                expect(counts.teamMembers).toBe(6);
+            });
         });
         describe('formatSessionCounts', () => {
             it('should format counts with all states', () => {
@@ -840,6 +912,7 @@ describe('SessionManager', () => {
                     pending_auto_approval: 0,
                     total: 4,
                     backgroundTasks: 0,
+                    teamMembers: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).toBe(' (1 Idle / 2 Busy / 1 Waiting)');
@@ -852,6 +925,7 @@ describe('SessionManager', () => {
                     pending_auto_approval: 0,
                     total: 3,
                     backgroundTasks: 0,
+                    teamMembers: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).toBe(' (2 Idle / 1 Waiting)');
@@ -864,6 +938,7 @@ describe('SessionManager', () => {
                     pending_auto_approval: 0,
                     total: 3,
                     backgroundTasks: 0,
+                    teamMembers: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).toBe(' (3 Busy)');
@@ -876,6 +951,7 @@ describe('SessionManager', () => {
                     pending_auto_approval: 0,
                     total: 0,
                     backgroundTasks: 0,
+                    teamMembers: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).toBe('');
@@ -888,6 +964,7 @@ describe('SessionManager', () => {
                     pending_auto_approval: 0,
                     total: 2,
                     backgroundTasks: 1,
+                    teamMembers: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).toContain('[BG]');
@@ -901,6 +978,7 @@ describe('SessionManager', () => {
                     pending_auto_approval: 0,
                     total: 2,
                     backgroundTasks: 5,
+                    teamMembers: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).toContain('[BG:5]');
@@ -914,11 +992,41 @@ describe('SessionManager', () => {
                     pending_auto_approval: 0,
                     total: 2,
                     backgroundTasks: 0,
+                    teamMembers: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
                 expect(formatted).not.toContain('[BG');
                 expect(formatted).toBe(' (1 Idle / 1 Busy)');
             });
+            it('should append [Team:N] tag when teamMembers > 0', () => {
+                const counts = {
+                    idle: 1,
+                    busy: 1,
+                    waiting_input: 0,
+                    pending_auto_approval: 0,
+                    total: 2,
+                    backgroundTasks: 0,
+                    teamMembers: 4,
+                };
+                const formatted = SessionManager.formatSessionCounts(counts);
+                expect(formatted).toContain('[Team:4]');
+                expect(formatted).toBe(' (1 Idle / 1 Busy \x1b[2m[Team:4]\x1b[0m)');
+            });
+            it('should append both [BG] and [Team:N] tags', () => {
+                const counts = {
+                    idle: 1,
+                    busy: 1,
+                    waiting_input: 0,
+                    pending_auto_approval: 0,
+                    total: 2,
+                    backgroundTasks: 1,
+                    teamMembers: 4,
+                };
+                const formatted = SessionManager.formatSessionCounts(counts);
+                expect(formatted).toContain('[BG]');
+                expect(formatted).toContain('[Team:4]');
+                expect(formatted).toBe(' (1 Idle / 1 Busy \x1b[2m[BG]\x1b[0m \x1b[2m[Team:4]\x1b[0m)');
+            });
         });
     });
 });

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

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

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

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

package/dist/services/stateDetector/claude.js

@@ -45,4 +45,18 @@ export class ClaudeStateDetector extends BaseStateDetector {
         // No background task detected
         return 0;
     }
+    detectTeamMembers(terminal) {
+        const lines = this.getTerminalLines(terminal, 3);
+        // Look for the team member line containing "shift+↑ to expand"
+        const teamLine = lines.find(line => {
+            const lower = line.toLowerCase();
+            return (lower.includes('shift+↑ to expand') ||
+                lower.includes('shift+up to expand'));
+        });
+        if (!teamLine)
+            return 0;
+        // Extract @name patterns
+        const members = teamLine.match(/@[\w-]+/g);
+        return members ? members.length : 0;
+    }
 }

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

@@ -466,4 +466,68 @@ describe('ClaudeStateDetector', () => {
             expect(count).toBe(3);
         });
     });
+    describe('detectTeamMembers', () => {
+        it('should return 2 when two @name members are present with shift+↑ to expand', () => {
+            terminal = createMockTerminal([
+                'Some output',
+                '@main @architect · shift+↑ to expand',
+            ]);
+            const count = detector.detectTeamMembers(terminal);
+            expect(count).toBe(2);
+        });
+        it('should return 4 when four @name members are present', () => {
+            terminal = createMockTerminal([
+                'Some output',
+                '@main @architect @devils-advocate @ux-specialist · shift+↑ to expand',
+            ]);
+            const count = detector.detectTeamMembers(terminal);
+            expect(count).toBe(4);
+        });
+        it('should return 0 when no team line is present', () => {
+            terminal = createMockTerminal([
+                'Command completed successfully',
+                'Ready for next command',
+                '> ',
+            ]);
+            const count = detector.detectTeamMembers(terminal);
+            expect(count).toBe(0);
+        });
+        it('should return 0 when shift+↑ to expand is not present', () => {
+            terminal = createMockTerminal([
+                'Some output with @mention',
+                'Normal text',
+            ]);
+            const count = detector.detectTeamMembers(terminal);
+            expect(count).toBe(0);
+        });
+        it('should not match other shift+ shortcuts', () => {
+            terminal = createMockTerminal([
+                '@main @architect · shift+tab to auto-approve',
+            ]);
+            const count = detector.detectTeamMembers(terminal);
+            expect(count).toBe(0);
+        });
+        it('should return 0 for empty terminal', () => {
+            terminal = createMockTerminal([]);
+            const count = detector.detectTeamMembers(terminal);
+            expect(count).toBe(0);
+        });
+        it('should handle shift+up to expand variant', () => {
+            terminal = createMockTerminal(['@main @architect · shift+up to expand']);
+            const count = detector.detectTeamMembers(terminal);
+            expect(count).toBe(2);
+        });
+        it('should handle case-insensitive shift+↑ to expand', () => {
+            terminal = createMockTerminal(['@main @architect · SHIFT+↑ TO EXPAND']);
+            const count = detector.detectTeamMembers(terminal);
+            expect(count).toBe(2);
+        });
+        it('should handle @name patterns with hyphens', () => {
+            terminal = createMockTerminal([
+                '@team-lead @code-reviewer · shift+↑ to expand',
+            ]);
+            const count = detector.detectTeamMembers(terminal);
+            expect(count).toBe(2);
+        });
+    });
 });

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

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

package/dist/services/stateDetector/cline.js

@@ -24,4 +24,7 @@ export class ClineStateDetector extends BaseStateDetector {
     detectBackgroundTask(_terminal) {
         return 0;
     }
+    detectTeamMembers(_terminal) {
+        return 0;
+    }
 }

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

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

package/dist/services/stateDetector/codex.js

@@ -27,4 +27,7 @@ export class CodexStateDetector extends BaseStateDetector {
     detectBackgroundTask(_terminal) {
         return 0;
     }
+    detectTeamMembers(_terminal) {
+        return 0;
+    }
 }

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

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

package/dist/services/stateDetector/cursor.js

@@ -19,4 +19,7 @@ export class CursorStateDetector extends BaseStateDetector {
     detectBackgroundTask(_terminal) {
         return 0;
     }
+    detectTeamMembers(_terminal) {
+        return 0;
+    }
 }

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

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

package/dist/services/stateDetector/gemini.js

@@ -28,4 +28,7 @@ export class GeminiStateDetector extends BaseStateDetector {
     detectBackgroundTask(_terminal) {
         return 0;
     }
+    detectTeamMembers(_terminal) {
+        return 0;
+    }
 }

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

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

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

@@ -21,4 +21,7 @@ export class GitHubCopilotStateDetector extends BaseStateDetector {
     detectBackgroundTask(_terminal) {
         return 0;
     }
+    detectTeamMembers(_terminal) {
+        return 0;
+    }
 }

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

@@ -9,4 +9,5 @@ import { BaseStateDetector } from './base.js';
 export declare class KimiStateDetector extends BaseStateDetector {
     detectState(terminal: Terminal, _currentState: SessionState): SessionState;
     detectBackgroundTask(_terminal: Terminal): number;
+    detectTeamMembers(_terminal: Terminal): number;
 }

package/dist/services/stateDetector/kimi.js

@@ -41,4 +41,7 @@ export class KimiStateDetector extends BaseStateDetector {
         // Kimi CLI does not currently support background tasks
         return 0;
     }
+    detectTeamMembers(_terminal) {
+        return 0;
+    }
 }

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

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

package/dist/services/stateDetector/opencode.js

@@ -17,4 +17,7 @@ export class OpenCodeStateDetector extends BaseStateDetector {
     detectBackgroundTask(_terminal) {
         return 0;
     }
+    detectTeamMembers(_terminal) {
+        return 0;
+    }
 }

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

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

package/dist/utils/commandArgs.d.ts

@@ -0,0 +1,9 @@
+import type { StateDetectionStrategy } from '../types/index.js';
+/**
+ * Inject `--teammate-mode in-process` into args when running the `claude` command
+ * with the `claude` detection strategy. This prevents tmux conflicts when
+ * Claude Code's agent teams feature is used inside ccmanager's PTY-based sessions.
+ *
+ * Returns the original array unchanged if injection is not needed.
+ */
+export declare function injectTeammateMode(command: string, args: string[], detectionStrategy: StateDetectionStrategy | undefined): string[];

package/dist/utils/commandArgs.js

@@ -0,0 +1,15 @@
+/**
+ * Inject `--teammate-mode in-process` into args when running the `claude` command
+ * with the `claude` detection strategy. This prevents tmux conflicts when
+ * Claude Code's agent teams feature is used inside ccmanager's PTY-based sessions.
+ *
+ * Returns the original array unchanged if injection is not needed.
+ */
+export function injectTeammateMode(command, args, detectionStrategy) {
+    if (command === 'claude' &&
+        (detectionStrategy ?? 'claude') === 'claude' &&
+        !args.includes('--teammate-mode')) {
+        return [...args, '--teammate-mode', 'in-process'];
+    }
+    return args;
+}

package/dist/utils/commandArgs.test.d.ts

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

package/dist/utils/commandArgs.test.js

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { injectTeammateMode } from './commandArgs.js';
+describe('injectTeammateMode', () => {
+    it('should inject --teammate-mode in-process for claude command with claude strategy', () => {
+        const result = injectTeammateMode('claude', ['--resume'], 'claude');
+        expect(result).toEqual(['--resume', '--teammate-mode', 'in-process']);
+    });
+    it('should inject when detectionStrategy is undefined (defaults to claude)', () => {
+        const result = injectTeammateMode('claude', ['--resume'], undefined);
+        expect(result).toEqual(['--resume', '--teammate-mode', 'in-process']);
+    });
+    it('should append to existing args without mutating the original array', () => {
+        const original = ['--flag1', '--flag2'];
+        const result = injectTeammateMode('claude', original, 'claude');
+        expect(result).toEqual([
+            '--flag1',
+            '--flag2',
+            '--teammate-mode',
+            'in-process',
+        ]);
+        expect(original).toEqual(['--flag1', '--flag2']);
+        expect(result).not.toBe(original);
+    });
+    it('should inject into empty args array', () => {
+        const result = injectTeammateMode('claude', [], undefined);
+        expect(result).toEqual(['--teammate-mode', 'in-process']);
+    });
+    it('should not inject when --teammate-mode is already present', () => {
+        const args = ['--teammate-mode', 'tmux'];
+        const result = injectTeammateMode('claude', args, 'claude');
+        expect(result).toEqual(['--teammate-mode', 'tmux']);
+        expect(result).toBe(args);
+    });
+    it('should not inject for non-claude command', () => {
+        const args = ['--resume'];
+        const result = injectTeammateMode('gemini', args, 'claude');
+        expect(result).toEqual(['--resume']);
+        expect(result).toBe(args);
+    });
+    it('should not inject for non-claude detection strategy', () => {
+        const args = ['--resume'];
+        const result = injectTeammateMode('claude', args, 'gemini');
+        expect(result).toEqual(['--resume']);
+        expect(result).toBe(args);
+    });
+    it('should not inject for custom command even with claude-like name', () => {
+        const args = ['--config', '/path'];
+        const result = injectTeammateMode('my-custom-claude', args, undefined);
+        expect(result).toEqual(['--config', '/path']);
+        expect(result).toBe(args);
+    });
+});

package/dist/utils/mutex.d.ts

@@ -48,6 +48,7 @@ export interface SessionStateData {
     autoApprovalReason: string | undefined;
     autoApprovalAbortController: AbortController | undefined;
     backgroundTaskCount: number;
+    teamMemberCount: number;
 }
 /**
  * Create initial session state data with default values.

package/dist/utils/mutex.js

@@ -86,5 +86,6 @@ export function createInitialSessionStateData() {
         autoApprovalReason: undefined,
         autoApprovalAbortController: undefined,
         backgroundTaskCount: 0,
+        teamMemberCount: 0,
     };
 }

package/dist/utils/worktreeUtils.js

@@ -82,7 +82,7 @@ export function prepareWorktreeItems(worktrees, sessions) {
         const session = sessions.find(s => s.worktreePath === wt.path);
         const stateData = session?.stateMutex.getSnapshot();
         const status = stateData
-            ? ` [${getStatusDisplay(stateData.state, stateData.backgroundTaskCount)}]`
+            ? ` [${getStatusDisplay(stateData.state, stateData.backgroundTaskCount, stateData.teamMemberCount)}]`
             : '';
         const fullBranchName = wt.branch
             ? wt.branch.replace('refs/heads/', '')

package/package.json

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