ccmanager 4.0.2 → 4.0.3

package/dist/components/App.js

@@ -42,6 +42,8 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     const [pendingWorktreeCreation, setPendingWorktreeCreation] = useState(null);
     // State for loading context - track flags for message composition
     const [loadingContext, setLoadingContext] = useState({});
+    // State for streaming devcontainer up logs
+    const [devcontainerLogs, setDevcontainerLogs] = useState([]);
     // Helper function to format error messages based on error type using _tag discrimination
     const formatErrorMessage = (error) => {
         switch (error._tag) {
@@ -59,8 +61,15 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     };
     // Helper function to create session with Effect-based error handling
     const createSessionWithEffect = useCallback(async (worktreePath, presetId, initialPrompt) => {
+        setDevcontainerLogs([]);
         const sessionEffect = devcontainerConfig
-            ? sessionManager.createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId, initialPrompt)
+            ? sessionManager.createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId, initialPrompt, (line) => {
+                setDevcontainerLogs(prev => {
+                    const next = [...prev, line];
+                    // Keep only the last 10 lines to avoid unbounded growth
+                    return next.length > 10 ? next.slice(-10) : next;
+                });
+            })
             : sessionManager.createSessionWithPresetEffect(worktreePath, presetId, initialPrompt);
         const result = await Effect.runPromise(Effect.either(sessionEffect));
         if (result._tag === 'Left') {
@@ -449,6 +458,11 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         setLoadingContext({ deleteBranch });
         setView('deleting-worktree');
         setError(null);
+        // Yield to the event loop so Ink can paint `deleting-worktree` before git work runs.
+        // Otherwise the confirmation UI stays visible until deletion finishes (no spinner).
+        await new Promise(resolve => {
+            setTimeout(resolve, 0);
+        });
         // Delete the worktrees sequentially using Effect
         let hasError = false;
         for (const path of worktreePaths) {
@@ -619,7 +633,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         // Use yellow color for devcontainer operations (longer duration),
         // cyan for standard session creation
         const color = devcontainerConfig ? 'yellow' : 'cyan';
-        return (_jsx(Box, { flexDirection: "column", children: _jsx(LoadingSpinner, { message: message, color: color }) }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(LoadingSpinner, { message: message, color: color }), devcontainerLogs.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: devcontainerLogs.map((line, i) => (_jsx(Text, { dimColor: true, children: line }, i))) }))] }));
     }
     if (view === 'creating-session-preset') {
         // Always display preset-specific message
@@ -631,7 +645,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
                 : 'Creating session with preset...';
         // Use yellow color for devcontainer, cyan for standard
         const color = devcontainerConfig ? 'yellow' : 'cyan';
-        return (_jsx(Box, { flexDirection: "column", children: _jsx(LoadingSpinner, { message: message, color: color }) }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(LoadingSpinner, { message: message, color: color }), devcontainerLogs.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: devcontainerLogs.map((line, i) => (_jsx(Text, { dimColor: true, children: line }, i))) }))] }));
     }
     if (view === 'clearing') {
         // Render nothing during the clearing phase to ensure clean transition

package/dist/services/bunTerminal.d.ts

@@ -27,6 +27,7 @@ export interface IPtyForkOptions {
     rows?: number;
     cwd?: string;
     env?: Record<string, string | undefined>;
+    rawMode?: boolean;
 }
 /**
  * Interface for interacting with a pseudo-terminal (PTY) instance.

package/dist/services/bunTerminal.js

@@ -57,9 +57,10 @@ class BunTerminal {
                 this._processBuffer();
             },
         });
-        // Match node-pty behavior by starting in raw mode (no canonical input/echo),
-        // while keeping Bun's output processing defaults intact.
-        this._terminal.setRawMode(true);
+        // Most interactive CLIs work best when the PTY starts in raw mode, but
+        // terminal proxy commands such as `devcontainer exec` manage termios
+        // themselves and break if the outer PTY is forced raw first.
+        this._terminal.setRawMode(options.rawMode ?? true);
         // Disable ONLCR in the PTY output flags to avoid double CRLF translation
         // when forwarding PTY output to the real stdout TTY.
         const ONLCR_FLAG = 0x0002;

package/dist/services/sessionManager.d.ts

@@ -96,7 +96,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
      * Create session with devcontainer integration using Effect-based error handling
      * @returns Effect that may fail with ProcessError (container/spawn failure) or ConfigError (invalid preset)
      */
-    createSessionWithDevcontainerEffect(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string, initialPrompt?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
+    createSessionWithDevcontainerEffect(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string, initialPrompt?: string, onLog?: (line: string) => void): Effect.Effect<Session, ProcessError | ConfigError, never>;
     destroy(): void;
     static getSessionCounts(sessions: Session[]): SessionCounts;
     static formatSessionCounts(counts: SessionCounts): string;

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

@@ -9,8 +9,17 @@ vi.mock('./bunTerminal.js', () => ({
         return null;
     }),
 }));
+// Helper to create a mock child process for child_process.spawn
+function createMockChildProcess(exitCode = 0) {
+    const stdout = new EventEmitter();
+    const stderr = new EventEmitter();
+    const proc = Object.assign(new EventEmitter(), { stdout, stderr });
+    process.nextTick(() => proc.emit('close', exitCode));
+    return proc;
+}
 // Mock child_process
 vi.mock('child_process', () => ({
+    spawn: vi.fn(() => createMockChildProcess(0)),
     exec: vi.fn(),
     execFile: vi.fn(),
 }));
@@ -167,18 +176,6 @@ describe('SessionManager Effect-based Operations', () => {
             });
             // Setup spawn mock
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Mock exec to succeed
-            const { exec } = await import('child_process');
-            const mockExec = vi.mocked(exec);
-            mockExec.mockImplementation((cmd, options, callback) => {
-                if (typeof options === 'function') {
-                    callback = options;
-                }
-                if (callback && typeof callback === 'function') {
-                    callback(null, 'Container started', '');
-                }
-                return {};
-            });
             const devcontainerConfig = {
                 upCommand: 'devcontainer up --workspace-folder .',
                 execCommand: 'devcontainer exec --workspace-folder .',
@@ -192,18 +189,9 @@ describe('SessionManager Effect-based Operations', () => {
             expect(session.devcontainerConfig).toEqual(devcontainerConfig);
         });
         it('should return Effect that fails with ProcessError when devcontainer up fails', async () => {
-            // Mock exec to fail
-            const { exec } = await import('child_process');
-            const mockExec = vi.mocked(exec);
-            mockExec.mockImplementation((cmd, options, callback) => {
-                if (typeof options === 'function') {
-                    callback = options;
-                }
-                if (callback && typeof callback === 'function') {
-                    callback(new Error('Container failed to start'), '', '');
-                }
-                return {};
-            });
+            // Mock spawn to return a process that exits with code 1
+            const { spawn: childSpawn } = await import('child_process');
+            vi.mocked(childSpawn).mockImplementation(() => createMockChildProcess(1));
             const devcontainerConfig = {
                 upCommand: 'devcontainer up --workspace-folder .',
                 execCommand: 'devcontainer exec --workspace-folder .',
@@ -217,11 +205,14 @@ describe('SessionManager Effect-based Operations', () => {
                 expect(result.left._tag).toBe('ProcessError');
                 if (result.left._tag === 'ProcessError') {
                     expect(result.left.command).toContain('devcontainer up');
-                    expect(result.left.message).toContain('Container failed');
+                    expect(result.left.message).toContain('Command exited with code 1');
                 }
             }
         });
         it('should return Effect that fails with ConfigError when preset not found', async () => {
+            // Reset childSpawn mock to succeed (devcontainer up should pass)
+            const { spawn: childSpawn } = await import('child_process');
+            vi.mocked(childSpawn).mockImplementation(() => createMockChildProcess(0));
             // Setup mocks - getPresetByIdEffect returns Left, getDefaultPreset returns undefined
             vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.left(new ValidationError({
                 field: 'presetId',
@@ -229,18 +220,6 @@ describe('SessionManager Effect-based Operations', () => {
                 receivedValue: 'invalid-preset',
             })));
             vi.mocked(configReader.getDefaultPreset).mockReturnValue(undefined);
-            // Mock exec to succeed (devcontainer up)
-            const { exec } = await import('child_process');
-            const mockExec = vi.mocked(exec);
-            mockExec.mockImplementation((cmd, options, callback) => {
-                if (typeof options === 'function') {
-                    callback = options;
-                }
-                if (callback && typeof callback === 'function') {
-                    callback(null, 'Container started', '');
-                }
-                return {};
-            });
             const devcontainerConfig = {
                 upCommand: 'devcontainer up',
                 execCommand: 'devcontainer exec',

package/dist/services/sessionManager.js

@@ -1,8 +1,7 @@
 import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
 import pkg from '@xterm/headless';
-import { exec } from 'child_process';
-import { promisify } from 'util';
+import { spawn as childSpawn } from 'child_process';
 import { configReader } from './config/configReader.js';
 import { executeStatusHook } from '../utils/hookExecutor.js';
 import { createStateDetector } from './stateDetector/index.js';
@@ -17,20 +16,20 @@ import { getTerminalScreenContent } from '../utils/screenCapture.js';
 import { injectTeammateMode } from '../utils/commandArgs.js';
 import { preparePresetLaunch } from '../utils/presetPrompt.js';
 const { Terminal } = pkg;
-const execAsync = promisify(exec);
 const TERMINAL_CONTENT_MAX_LINES = 300;
 export class SessionManager extends EventEmitter {
     sessions;
     waitingWithBottomBorder = new Map();
     busyTimers = new Map();
     autoApprovalDisabledWorktrees = new Set();
-    async spawn(command, args, worktreePath) {
+    async spawn(command, args, worktreePath, options = {}) {
         const spawnOptions = {
             name: 'xterm-256color',
             cols: process.stdout.columns || 80,
             rows: process.stdout.rows || 24,
             cwd: worktreePath,
             env: process.env,
+            ...(options.rawMode === undefined ? {} : { rawMode: options.rawMode }),
         };
         return spawn(command, args, spawnOptions);
     }
@@ -340,7 +339,7 @@ export class SessionManager extends EventEmitter {
                             'claude',
                             ...fallbackClaudeArgs,
                         ];
-                        fallbackProcess = await this.spawn(devcontainerCmd, fallbackFullArgs, session.worktreePath);
+                        fallbackProcess = await this.spawn(devcontainerCmd, fallbackFullArgs, session.worktreePath, { rawMode: false });
                     }
                     else {
                         // Regular fallback without devcontainer
@@ -635,12 +634,43 @@ export class SessionManager extends EventEmitter {
      * Create session with devcontainer integration using Effect-based error handling
      * @returns Effect that may fail with ProcessError (container/spawn failure) or ConfigError (invalid preset)
      */
-    createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId, initialPrompt) {
+    createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId, initialPrompt, onLog) {
         return Effect.tryPromise({
             try: async () => {
-                // Execute devcontainer up command first
+                // Execute devcontainer up command, streaming output in real-time
                 try {
-                    await execAsync(devcontainerConfig.upCommand, { cwd: worktreePath });
+                    await new Promise((resolve, reject) => {
+                        const parts = devcontainerConfig.upCommand.split(/\s+/);
+                        const cmd = parts[0];
+                        const args = parts.slice(1);
+                        const proc = childSpawn(cmd, args, {
+                            cwd: worktreePath,
+                            stdio: ['ignore', 'pipe', 'pipe'],
+                            shell: false,
+                        });
+                        const handleData = (data) => {
+                            const text = data.toString();
+                            for (const line of text.split('\n')) {
+                                const trimmed = line.trimEnd();
+                                if (trimmed) {
+                                    onLog?.(trimmed);
+                                }
+                            }
+                        };
+                        proc.stdout?.on('data', handleData);
+                        proc.stderr?.on('data', handleData);
+                        proc.on('error', err => {
+                            reject(err);
+                        });
+                        proc.on('close', code => {
+                            if (code === 0) {
+                                resolve();
+                            }
+                            else {
+                                reject(new Error(`Command exited with code ${code}`));
+                            }
+                        });
+                    });
                 }
                 catch (error) {
                     throw new ProcessError({
@@ -658,7 +688,7 @@ export class SessionManager extends EventEmitter {
                 const presetArgs = launch.args;
                 const fullArgs = [...execArgs, '--', preset.command, ...presetArgs];
                 // Spawn the process within devcontainer
-                const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath);
+                const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath, { rawMode: false });
                 const session = await this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
                     presetName: preset.name,

package/dist/services/sessionManager.test.js

@@ -3,7 +3,16 @@ 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';
+import { spawn as childSpawn } from 'child_process';
+// Helper to create a mock child process for child_process.spawn
+function createMockChildProcess(exitCode = 0) {
+    const stdout = new EventEmitter();
+    const stderr = new EventEmitter();
+    const proc = Object.assign(new EventEmitter(), { stdout, stderr });
+    // Emit 'close' asynchronously so listeners can be attached
+    process.nextTick(() => proc.emit('close', exitCode));
+    return proc;
+}
 // Mock bunTerminal
 vi.mock('./bunTerminal.js', () => ({
     spawn: vi.fn(function () {
@@ -12,12 +21,11 @@ vi.mock('./bunTerminal.js', () => ({
 }));
 // Mock child_process
 vi.mock('child_process', () => ({
-    exec: vi.fn(function () {
-        return null;
-    }),
-    execFile: vi.fn(function () {
-        return null;
+    spawn: vi.fn(function () {
+        return createMockChildProcess(0);
     }),
+    exec: vi.fn(),
+    execFile: vi.fn(),
 }));
 // Mock configuration manager
 vi.mock('./config/configReader.js', () => ({
@@ -388,24 +396,8 @@ describe('SessionManager', () => {
     });
     describe('createSessionWithDevcontainerEffect', () => {
         beforeEach(() => {
-            // Reset shouldFail flag
-            const mockExec = vi.mocked(exec);
-            mockExec.shouldFail = false;
-            // Setup exec mock to work with promisify
-            mockExec.mockImplementation(((...args) => {
-                const [command, , callback] = args;
-                if (callback) {
-                    // Handle callback style
-                    if (command.includes('devcontainer up')) {
-                        if (mockExec.shouldFail) {
-                            callback(new Error('Container startup failed'));
-                        }
-                        else {
-                            callback(null, '', '');
-                        }
-                    }
-                }
-            }));
+            // Setup childSpawn mock to return a successful mock child process
+            vi.mocked(childSpawn).mockImplementation(() => createMockChildProcess(0));
         });
         it('should execute devcontainer up command before creating session', async () => {
             // Setup mock preset
@@ -434,7 +426,7 @@ describe('SessionManager', () => {
                 '--resume',
                 '--teammate-mode',
                 'in-process',
-            ], expect.objectContaining({ cwd: '/test/worktree' }));
+            ], expect.objectContaining({ cwd: '/test/worktree', rawMode: false }));
         });
         it('should use specific preset when ID provided', async () => {
             // Setup mock preset
@@ -465,15 +457,14 @@ describe('SessionManager', () => {
             ], expect.any(Object));
         });
         it('should throw error when devcontainer up fails', async () => {
-            // Setup exec to fail
-            const mockExec = vi.mocked(exec);
-            mockExec.shouldFail = true;
+            // Setup childSpawn to return a process that exits with code 1
+            vi.mocked(childSpawn).mockImplementation(() => createMockChildProcess(1));
             // Create session with devcontainer
             const devcontainerConfig = {
                 upCommand: 'devcontainer up',
                 execCommand: 'devcontainer exec',
             };
-            await expect(Effect.runPromise(sessionManager.createSessionWithDevcontainerEffect('/test/worktree', devcontainerConfig))).rejects.toThrow('Failed to start devcontainer: Container startup failed');
+            await expect(Effect.runPromise(sessionManager.createSessionWithDevcontainerEffect('/test/worktree', devcontainerConfig))).rejects.toThrow('Failed to start devcontainer: Command exited with code 1');
         });
         it('should create a new session each time for multi-session support', async () => {
             // Setup mock preset
@@ -540,17 +531,6 @@ describe('SessionManager', () => {
             });
             // Setup spawn mock
             vi.mocked(spawn).mockReturnValue(mockPty);
-            const mockExec = vi.mocked(exec);
-            mockExec.mockImplementation((cmd, options, callback) => {
-                if (typeof options === 'function') {
-                    callback = options;
-                    options = undefined;
-                }
-                if (callback && typeof callback === 'function') {
-                    callback(null, 'Container started', '');
-                }
-                return {};
-            });
             await Effect.runPromise(sessionManager.createSessionWithDevcontainerEffect('/test/worktree2', {
                 upCommand: 'devcontainer up --workspace-folder .',
                 execCommand: 'devcontainer exec --workspace-folder .',
@@ -566,20 +546,10 @@ describe('SessionManager', () => {
                 'in-process',
             ], expect.objectContaining({
                 cwd: '/test/worktree2',
+                rawMode: false,
             }));
         });
         it('should use preset with devcontainer', async () => {
-            const mockExec = vi.mocked(exec);
-            mockExec.mockImplementation((cmd, options, callback) => {
-                if (typeof options === 'function') {
-                    callback = options;
-                    options = undefined;
-                }
-                if (callback && typeof callback === 'function') {
-                    callback(null, 'Container started', '');
-                }
-                return {};
-            });
             await Effect.runPromise(sessionManager.createSessionWithDevcontainerEffect('/test/worktree', {
                 upCommand: 'devcontainer up --workspace-folder .',
                 execCommand: 'devcontainer exec --workspace-folder .',
@@ -594,17 +564,6 @@ describe('SessionManager', () => {
             });
         });
         it('should parse exec command and append preset command', async () => {
-            const mockExec = vi.mocked(exec);
-            mockExec.mockImplementation((cmd, options, callback) => {
-                if (typeof options === 'function') {
-                    callback = options;
-                    options = undefined;
-                }
-                if (callback && typeof callback === 'function') {
-                    callback(null, 'Container started', '');
-                }
-                return {};
-            });
             const config = {
                 upCommand: 'devcontainer up --workspace-folder /path/to/project',
                 execCommand: 'devcontainer exec --workspace-folder /path/to/project --user vscode',
@@ -623,17 +582,6 @@ describe('SessionManager', () => {
             ], expect.any(Object));
         });
         it('should handle preset with args in devcontainer', async () => {
-            const mockExec = vi.mocked(exec);
-            mockExec.mockImplementation((cmd, options, callback) => {
-                if (typeof options === 'function') {
-                    callback = options;
-                    options = undefined;
-                }
-                if (callback && typeof callback === 'function') {
-                    callback(null, 'Container started', '');
-                }
-                return {};
-            });
             vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.right({
                 id: 'claude-with-args',
                 name: 'Claude with Args',
@@ -657,17 +605,6 @@ describe('SessionManager', () => {
             ], expect.any(Object));
         });
         it('should use empty args as fallback in devcontainer when no fallback args specified', async () => {
-            const mockExec = vi.mocked(exec);
-            mockExec.mockImplementation((cmd, options, callback) => {
-                if (typeof options === 'function') {
-                    callback = options;
-                    options = undefined;
-                }
-                if (callback && typeof callback === 'function') {
-                    callback(null, 'Container started', '');
-                }
-                return {};
-            });
             // Setup preset without fallback args
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -713,23 +650,12 @@ describe('SessionManager', () => {
                 'claude',
                 '--teammate-mode',
                 'in-process',
-            ], expect.objectContaining({ cwd: '/test/worktree' }));
+            ], expect.objectContaining({ cwd: '/test/worktree', rawMode: false }));
             // Verify session process was replaced
             expect(session.process).toBe(secondMockPty);
             expect(session.isPrimaryCommand).toBe(false);
         });
         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') {
-                    callback = options;
-                    options = undefined;
-                }
-                if (callback && typeof callback === 'function') {
-                    callback(null, 'Container started', '');
-                }
-                return {};
-            });
             // Setup preset with args
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -774,7 +700,7 @@ describe('SessionManager', () => {
                 'claude',
                 '--teammate-mode',
                 'in-process',
-            ], expect.objectContaining({ cwd: '/test/worktree' }));
+            ], expect.objectContaining({ cwd: '/test/worktree', rawMode: false }));
             // Verify session process was replaced
             expect(session.process).toBe(secondMockPty);
             expect(session.isPrimaryCommand).toBe(false);

package/dist/services/stateDetector/cursor.js

@@ -1,4 +1,8 @@
 import { BaseStateDetector } from './base.js';
+// Spinner symbols used by Cursor during active processing
+const CURSOR_SPINNER_CHARS = '⬡⬢';
+// Like Claude's spinner activity: "<symbol> <word>ing…"; Cursor often uses ASCII dots (.. or …)
+const SPINNER_ACTIVITY_PATTERN = new RegExp(`^\\s*[${CURSOR_SPINNER_CHARS}] \\S+ing(?:.*\u2026|.*\\.{2,})`, 'm');
 export class CursorStateDetector extends BaseStateDetector {
     detectState(terminal, _currentState) {
         const content = this.getTerminalContent(terminal, 30);
@@ -16,6 +20,10 @@ export class CursorStateDetector extends BaseStateDetector {
         if (lowerContent.includes('ctrl+c to stop')) {
             return 'busy';
         }
+        // Spinner activity (e.g. "⬡ Grepping..", "⬢ Reading…") — case-sensitive on original buffer
+        if (SPINNER_ACTIVITY_PATTERN.test(content)) {
+            return 'busy';
+        }
         // Otherwise idle - Priority 3
         return 'idle';
     }

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

@@ -138,6 +138,18 @@ describe('CursorStateDetector', () => {
         // Assert
         expect(state).toBe('busy');
     });
+    it('should detect busy state for spinner activity (⬡ …ing..)', () => {
+        terminal = createMockTerminal(['  ⬡ Grepping..', 'Some footer']);
+        expect(detector.detectState(terminal, 'idle')).toBe('busy');
+    });
+    it('should detect busy state for spinner activity (⬢ …ing...)', () => {
+        terminal = createMockTerminal(['  ⬢ Reading...']);
+        expect(detector.detectState(terminal, 'idle')).toBe('busy');
+    });
+    it('should detect busy state for spinner activity with Unicode ellipsis', () => {
+        terminal = createMockTerminal(['⬡ Searching\u2026']);
+        expect(detector.detectState(terminal, 'idle')).toBe('busy');
+    });
     it('should detect idle state when no patterns match', () => {
         // Arrange
         terminal = createMockTerminal(['Normal output', 'Some message', 'Ready']);

package/package.json

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