ccmanager 4.0.1 → 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/components/ConfigureStatusHooks.js

@@ -105,7 +105,7 @@ const ConfigureStatusHooks = ({ onComplete, }) => {
         return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "green", children: "\u2713 Configuration saved successfully!" }) }));
     }
     if (view === 'edit') {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "green", children: ["Configure ", STATUS_LABELS[selectedStatus], " Hook"] }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Command to execute when status changes to", ' ', STATUS_LABELS[selectedStatus], ":"] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(TextInputWrapper, { value: currentCommand, onChange: setCurrentCommand, onSubmit: handleCommandSubmit, placeholder: "Enter command (e.g., notify-send 'Claude is idle')" }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Enabled: ", currentEnabled ? '✓' : '✗', " (Press Tab to toggle)"] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Environment variables available: CCMANAGER_OLD_STATE, CCMANAGER_NEW_STATE," }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `CCMANAGER_WORKTREE_PATH, CCMANAGER_WORKTREE_DIR, CCMANAGER_WORKTREE_BRANCH, CCMANAGER_SESSION_ID` }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to save, Tab to toggle enabled, Esc to cancel" }) })] }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "green", children: ["Configure ", STATUS_LABELS[selectedStatus], " Hook"] }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Command to execute when status changes to", ' ', STATUS_LABELS[selectedStatus], ":"] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(TextInputWrapper, { value: currentCommand, onChange: setCurrentCommand, onSubmit: handleCommandSubmit, placeholder: "Enter command (e.g., notify-send 'Claude is idle')" }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Enabled: ", currentEnabled ? '✓' : '✗', " (Press Tab to toggle)"] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Environment variables available: CCMANAGER_OLD_STATE, CCMANAGER_NEW_STATE," }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `CCMANAGER_WORKTREE_PATH, CCMANAGER_WORKTREE_DIR, CCMANAGER_WORKTREE_BRANCH, CCMANAGER_SESSION_ID, CCMANAGER_PRESET_NAME` }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to save, Tab to toggle enabled, Esc to cancel" }) })] }));
     }
     const scopeLabel = scope === 'project' ? 'Project' : 'Global';
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "green", children: ["Configure Status Hooks (", scopeLabel, ")"] }) }), isInheriting && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { backgroundColor: "cyan", color: "black", children: [' ', "\uD83D\uDCCB Inheriting from global configuration", ' '] }) })), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Set commands to run when session status changes:" }) }), _jsx(SelectInput, { items: getMenuItems(), onSelect: handleMenuSelect, isFocused: true, limit: 10 }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Esc to go back" }) })] }));

package/dist/components/Session.js

@@ -4,11 +4,6 @@ import { shortcutManager } from '../services/shortcutManager.js';
 const Session = ({ session, sessionManager, onReturnToMenu, }) => {
     const { stdout } = useStdout();
     const isExitingRef = useRef(false);
-    const stripOscColorSequences = (input) => {
-        // Remove default foreground/background color OSC sequences that Codex emits
-        // These sequences leak as literal text when replaying buffered output
-        return input.replace(/\x1B\](?:10|11);[^\x07\x1B]*(?:\x07|\x1B\\)/g, '');
-    };
     const normalizeLineEndings = (input) => {
         // Ensure LF moves to column 0 to prevent cursor drift when ONLCR is disabled.
         let normalized = '';
@@ -32,22 +27,40 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             // protocol / modifyOtherKeys / focus tracking) so they don't leak into other
             // sessions after we detach.
             stdout.write('\x1b[>0u'); // Disable kitty keyboard protocol (CSI u sequences)
-            stdout.write('\x1b[>4m'); // Disable xterm modifyOtherKeys extensions
+            stdout.write('\x1b[>4;0m'); // Disable xterm modifyOtherKeys extensions
             stdout.write('\x1b[?1004l'); // Disable focus reporting
             stdout.write('\x1b[?2004l'); // Disable bracketed paste (can interfere with shortcuts)
             stdout.write('\x1b[?7h'); // Re-enable auto-wrap
         };
-        const sanitizeReplayBuffer = (input) => {
-            // Remove terminal mode toggles emitted by Codex so replay doesn't re-enable them
-            // on our own TTY when restoring the session view.
-            return stripOscColorSequences(input)
-                .replace(/\x1B\[>4;?\d*m/g, '') // modifyOtherKeys set/reset
-                .replace(/\x1B\[>[0-9;]*u/g, '') // kitty keyboard protocol enables
-                .replace(/\x1B\[\?1004[hl]/g, '') // focus tracking
-                .replace(/\x1B\[\?2004[hl]/g, ''); // bracketed paste
+        // Set up raw input handling
+        const stdin = process.stdin;
+        // Configure stdin for PTY passthrough
+        if (stdin.isTTY) {
+            stdin.setRawMode(true);
+            stdin.resume();
+        }
+        stdin.setEncoding('utf8');
+        const handleStdinData = (data) => {
+            if (isExitingRef.current)
+                return;
+            // Check for return to menu shortcut
+            if (shortcutManager.matchesRawInput('returnToMenu', data)) {
+                // Disable any extended input modes that might have been enabled by the PTY
+                if (stdout) {
+                    resetTerminalInputModes();
+                }
+                // Remove our listener — Ink will reconfigure stdin when Menu mounts
+                stdin.removeListener('data', handleStdinData);
+                onReturnToMenu();
+                return;
+            }
+            if (session.stateMutex.getSnapshot().state === 'pending_auto_approval') {
+                sessionManager.cancelAutoApproval(session.id, 'User input received during auto-approval');
+            }
+            // Pass all other input directly to the PTY
+            session.process.write(data);
         };
-        // Reset modes immediately on entry in case a previous session left them on
-        resetTerminalInputModes();
+        stdin.on('data', handleStdinData);
         // Prevent line wrapping from drifting redraws in TUIs that rely on cursor-up clears.
         stdout.write('\x1b[?7l');
         // Clear screen when entering session
@@ -61,9 +74,8 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
                 // Concatenate all history buffers and write at once for better performance
                 const allHistory = Buffer.concat(restoredSession.outputHistory);
                 const historyStr = allHistory.toString('utf8');
-                // Sanitize and normalize the output
-                const sanitized = sanitizeReplayBuffer(historyStr);
-                const normalized = normalizeLineEndings(sanitized);
+                // Normalize the output
+                const normalized = normalizeLineEndings(historyStr);
                 // Remove leading clear screen sequences to avoid double-clear
                 const cleaned = normalized
                     .replace(/^\x1B\[2J/g, '')
@@ -75,6 +87,21 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         };
         // Listen for restore event first
         sessionManager.on('sessionRestore', handleSessionRestore);
+        // Listen for session data events
+        const handleSessionData = (activeSession, data) => {
+            // Only handle data for our session
+            if (activeSession.id === session.id && !isExitingRef.current) {
+                stdout.write(normalizeLineEndings(data));
+            }
+        };
+        const handleSessionExit = (exitedSession) => {
+            if (exitedSession.id === session.id) {
+                isExitingRef.current = true;
+                // Don't call onReturnToMenu here - App component handles it
+            }
+        };
+        sessionManager.on('sessionData', handleSessionData);
+        sessionManager.on('sessionExit', handleSessionExit);
         // Mark session as active (this will trigger the restore event)
         sessionManager.setSessionActive(session.id, true);
         // Immediately resize the PTY and terminal to current dimensions
@@ -93,21 +120,6 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         catch {
             /* empty */
         }
-        // Listen for session data events
-        const handleSessionData = (activeSession, data) => {
-            // Only handle data for our session
-            if (activeSession.id === session.id && !isExitingRef.current) {
-                stdout.write(normalizeLineEndings(data));
-            }
-        };
-        const handleSessionExit = (exitedSession) => {
-            if (exitedSession.id === session.id) {
-                isExitingRef.current = true;
-                // Don't call onReturnToMenu here - App component handles it
-            }
-        };
-        sessionManager.on('sessionData', handleSessionData);
-        sessionManager.on('sessionExit', handleSessionExit);
         // Handle terminal resize
         const handleResize = () => {
             const cols = process.stdout.columns || 80;
@@ -119,35 +131,6 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             }
         };
         stdout.on('resize', handleResize);
-        // Set up raw input handling
-        const stdin = process.stdin;
-        // Configure stdin for PTY passthrough
-        if (stdin.isTTY) {
-            stdin.setRawMode(true);
-            stdin.resume();
-        }
-        stdin.setEncoding('utf8');
-        const handleStdinData = (data) => {
-            if (isExitingRef.current)
-                return;
-            // Check for return to menu shortcut
-            if (shortcutManager.matchesRawInput('returnToMenu', data)) {
-                // Disable any extended input modes that might have been enabled by the PTY
-                if (stdout) {
-                    resetTerminalInputModes();
-                }
-                // Remove our listener — Ink will reconfigure stdin when Menu mounts
-                stdin.removeListener('data', handleStdinData);
-                onReturnToMenu();
-                return;
-            }
-            if (session.stateMutex.getSnapshot().state === 'pending_auto_approval') {
-                sessionManager.cancelAutoApproval(session.id, 'User input received during auto-approval');
-            }
-            // Pass all other input directly to the PTY
-            session.process.write(data);
-        };
-        stdin.on('data', handleStdinData);
         return () => {
             // Remove our stdin listener
             stdin.removeListener('data', handleStdinData);

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);
     }
@@ -217,6 +216,7 @@ export class SessionManager extends EventEmitter {
             terminal,
             stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
+            presetName: options.presetName,
             detectionStrategy,
             devcontainerConfig: options.devcontainerConfig ?? undefined,
             stateMutex: new Mutex(createInitialSessionStateData()),
@@ -257,6 +257,7 @@ export class SessionManager extends EventEmitter {
                 const ptyProcess = await this.spawn(command, args, worktreePath);
                 const session = await this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
+                    presetName: preset.name,
                     detectionStrategy: preset.detectionStrategy,
                 });
                 if (launch.stdinPayload) {
@@ -338,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
@@ -633,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({
@@ -656,9 +688,10 @@ 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,
                     detectionStrategy: preset.detectionStrategy,
                     devcontainerConfig,
                 });

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/dist/types/index.d.ts

@@ -29,6 +29,7 @@ export interface Session {
     terminal: Terminal;
     stateCheckInterval: NodeJS.Timeout | undefined;
     isPrimaryCommand: boolean;
+    presetName: string | undefined;
     detectionStrategy: StateDetectionStrategy | undefined;
     devcontainerConfig: DevcontainerConfig | undefined;
     /**

package/dist/utils/hookExecutor.js

@@ -1,5 +1,5 @@
 import { spawn } from 'child_process';
-import { dirname } from 'path';
+import { basename } from 'path';
 import { Effect } from 'effect';
 import { ProcessError } from '../types/errors.js';
 import { WorktreeService } from '../services/worktreeService.js';
@@ -149,12 +149,13 @@ export function executeStatusHook(oldState, newState, session) {
         // Build environment for status hook
         const environment = {
             CCMANAGER_WORKTREE_PATH: session.worktreePath,
-            CCMANAGER_WORKTREE_DIR: dirname(session.worktreePath),
+            CCMANAGER_WORKTREE_DIR: basename(session.worktreePath),
             CCMANAGER_WORKTREE_BRANCH: branch,
             CCMANAGER_GIT_ROOT: session.worktreePath, // For status hooks, we use worktree path as cwd
             CCMANAGER_OLD_STATE: oldState,
             CCMANAGER_NEW_STATE: newState,
             CCMANAGER_SESSION_ID: session.id,
+            CCMANAGER_PRESET_NAME: session.presetName || '',
         };
         yield* Effect.catchAll(executeHook(hook.command, session.worktreePath, environment), error => {
             // Log error but don't throw - hooks should not break the main flow

package/dist/utils/hookExecutor.test.js

@@ -384,6 +384,7 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
+                presetName: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
@@ -440,6 +441,7 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
+                presetName: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
@@ -494,6 +496,7 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
+                presetName: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
@@ -550,6 +553,7 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
+                presetName: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),

package/dist/utils/worktreeUtils.test.js

@@ -133,6 +133,7 @@ describe('prepareSessionItems', () => {
         terminal: {},
         stateCheckInterval: undefined,
         isPrimaryCommand: true,
+        presetName: undefined,
         detectionStrategy: 'claude',
         devcontainerConfig: undefined,
         stateMutex: new Mutex({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.0.1",
+	"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.1",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.0.1",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.0.1",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.0.1",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.0.1"
+		"@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",