ccmanager 4.0.2 → 4.0.4

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

@@ -59,9 +59,8 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     /**
      * Sets up exit handler for the session process.
      * When the process exits with code 1 and it's the primary command,
-     * it will attempt to spawn a fallback process.
-     * If fallbackArgs are configured, they will be used.
-     * If no fallbackArgs are configured, the command will be retried with no arguments.
+     * it will attempt a single retry using the configured command with fallback args.
+     * If fallbackArgs are not configured, it retries the configured command with no args.
      */
     private setupExitHandler;
     private setupBackgroundHandler;
@@ -96,7 +95,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);
     }
@@ -208,6 +207,8 @@ export class SessionManager extends EventEmitter {
             worktreePath,
             sessionNumber: maxNumber + 1,
             sessionName: undefined,
+            command: options.command ?? 'claude',
+            fallbackArgs: options.fallbackArgs,
             lastAccessedAt: Date.now(),
             process: ptyProcess,
             output: [],
@@ -258,6 +259,8 @@ export class SessionManager extends EventEmitter {
                 const ptyProcess = await this.spawn(command, args, worktreePath);
                 const session = await this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
+                    command,
+                    fallbackArgs: preset.fallbackArgs,
                     presetName: preset.name,
                     detectionStrategy: preset.detectionStrategy,
                 });
@@ -316,9 +319,8 @@ export class SessionManager extends EventEmitter {
     /**
      * Sets up exit handler for the session process.
      * When the process exits with code 1 and it's the primary command,
-     * it will attempt to spawn a fallback process.
-     * If fallbackArgs are configured, they will be used.
-     * If no fallbackArgs are configured, the command will be retried with no arguments.
+     * it will attempt a single retry using the configured command with fallback args.
+     * If fallbackArgs are not configured, it retries the configured command with no args.
      */
     setupExitHandler(session) {
         session.process.onExit(async (e) => {
@@ -326,26 +328,23 @@ export class SessionManager extends EventEmitter {
             if (e.exitCode === 1 && !e.signal && session.isPrimaryCommand) {
                 try {
                     let fallbackProcess;
+                    const fallbackArgs = injectTeammateMode(session.command, session.fallbackArgs ?? [], session.detectionStrategy);
                     // Check if we're in a devcontainer session
                     if (session.devcontainerConfig) {
                         // Parse the exec command to extract arguments
                         const execParts = session.devcontainerConfig.execCommand.split(/\s+/);
                         const devcontainerCmd = execParts[0] || 'devcontainer';
                         const execArgs = execParts.slice(1);
-                        // Build fallback command for devcontainer
-                        const fallbackClaudeArgs = injectTeammateMode('claude', [], session.detectionStrategy);
                         const fallbackFullArgs = [
                             ...execArgs,
                             '--',
-                            'claude',
-                            ...fallbackClaudeArgs,
+                            session.command,
+                            ...fallbackArgs,
                         ];
-                        fallbackProcess = await this.spawn(devcontainerCmd, fallbackFullArgs, session.worktreePath);
+                        fallbackProcess = await this.spawn(devcontainerCmd, fallbackFullArgs, session.worktreePath, { rawMode: false });
                     }
                     else {
-                        // Regular fallback without devcontainer
-                        const fallbackArgs = injectTeammateMode('claude', [], session.detectionStrategy);
-                        fallbackProcess = await this.spawn('claude', fallbackArgs, session.worktreePath);
+                        fallbackProcess = await this.spawn(session.command, fallbackArgs, session.worktreePath);
                     }
                     // Replace the process
                     session.process = fallbackProcess;
@@ -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,9 +688,11 @@ 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,
+                    command: preset.command,
+                    fallbackArgs: preset.fallbackArgs,
                     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', () => ({
@@ -230,13 +238,14 @@ describe('SessionManager', () => {
             // Expect createSessionWithPresetEffect to throw the original error
             await expect(Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'))).rejects.toThrow('Command not found');
         });
-        it('should fallback to default command when main command exits with code 1', async () => {
+        it('should retry the configured command with fallback args when main command exits with code 1', async () => {
             // Setup mock preset with args
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
                 args: ['--invalid-flag'],
+                fallbackArgs: ['--safe-flag'],
             });
             // First spawn attempt - will exit with code 1
             const firstMockPty = new MockPty();
@@ -254,11 +263,13 @@ describe('SessionManager', () => {
             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 the configured fallback args
             expect(spawn).toHaveBeenCalledTimes(2);
-            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--teammate-mode', 'in-process'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--safe-flag', '--teammate-mode', 'in-process'], expect.objectContaining({ cwd: '/test/worktree' }));
             // Verify session process was replaced
             expect(session.process).toBe(secondMockPty);
+            expect(session.command).toBe('claude');
+            expect(session.fallbackArgs).toEqual(['--safe-flag']);
             expect(session.isPrimaryCommand).toBe(false);
         });
         it('should not use fallback if main command succeeds', async () => {
@@ -310,8 +321,37 @@ describe('SessionManager', () => {
             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.command).toBe('claude');
+            expect(session.fallbackArgs).toBeUndefined();
             expect(session.isPrimaryCommand).toBe(false);
         });
+        it('should cleanup and emit exit when fallback command also exits with code 1', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'opencode',
+                args: ['run', '--bad-flag'],
+                fallbackArgs: ['run', '--safe-mode'],
+                detectionStrategy: 'opencode',
+            });
+            const firstMockPty = new MockPty();
+            const secondMockPty = new MockPty();
+            let exitedSession = null;
+            vi.mocked(spawn)
+                .mockReturnValueOnce(firstMockPty)
+                .mockReturnValueOnce(secondMockPty);
+            sessionManager.on('sessionExit', (session) => {
+                exitedSession = session;
+            });
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            firstMockPty.emit('exit', { exitCode: 1 });
+            await new Promise(resolve => setTimeout(resolve, 50));
+            secondMockPty.emit('exit', { exitCode: 1 });
+            await new Promise(resolve => setTimeout(resolve, 50));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'opencode', ['run', '--safe-mode'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(exitedSession).toBe(session);
+            expect(sessionManager.getSessionsForWorktree('/test/worktree')).toHaveLength(0);
+        });
         it('should handle custom command configuration', async () => {
             // Setup mock preset with custom command
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
@@ -388,24 +428,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 +458,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 +489,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 +563,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 +578,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 +596,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 +614,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 +637,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,29 +682,19 @@ 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 {};
-            });
+        it('should retry the configured command with fallback args in devcontainer when primary command exits with code 1', async () => {
             // Setup preset with args
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
                 args: ['--bad-flag'],
+                fallbackArgs: ['--safe-flag'],
             });
             // First spawn attempt - will exit with code 1
             const firstMockPty = new MockPty();
@@ -764,7 +723,7 @@ describe('SessionManager', () => {
             firstMockPty.emit('exit', { exitCode: 1 });
             // Wait for fallback to occur
             await new Promise(resolve => setTimeout(resolve, 50));
-            // Verify fallback spawn was called with teammate-mode args
+            // Verify fallback spawn was called with the configured fallback args
             expect(spawn).toHaveBeenCalledTimes(2);
             expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', [
                 'exec',
@@ -772,9 +731,10 @@ describe('SessionManager', () => {
                 '.',
                 '--',
                 'claude',
+                '--safe-flag',
                 '--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);
@@ -9,13 +13,21 @@ export class CursorStateDetector extends BaseStateDetector {
             /auto .* \(shift\+tab\)/.test(lowerContent) ||
             /allow .+ \(y\)/.test(lowerContent) ||
             /run .+ \(y\)/.test(lowerContent) ||
-            lowerContent.includes('skip (esc or n)')) {
+            lowerContent.includes('skip (esc or n)') ||
+            lowerContent.includes('write to this file?') ||
+            lowerContent.includes('reject & propose changes') ||
+            (lowerContent.includes('add write(') &&
+                lowerContent.includes('allowlist'))) {
             return 'waiting_input';
         }
         // Check for busy state - Priority 2
         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

@@ -114,6 +114,21 @@ describe('CursorStateDetector', () => {
         // Assert
         expect(state).toBe('waiting_input');
     });
+    it('should detect waiting_input state for Write to this file? prompt', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            ' │ Write to this file?                                                                                                                                                                                                                                                                                                                                                                  │',
+            ' │ in /Users/kbwo/go/projects/github.com/kbwo/ccmanager--feature-takt/src/services/stateDetector/takt.ts                                                                                                                                                                                                                                                                                │',
+            ' │  → Proceed (y)                                                                                                                                                                                                                                                                                                                                                                       │',
+            ' │    Reject & propose changes (esc or n or p)                                                                                                                                                                                                                                                                                                                                          │',
+            ' │    Add Write(/Users/.../takt.ts) to allowlist? (tab)                                                                                                                                                                                                                                                                                                                                 │',
+            ' │    Run Everything (shift+tab)                                                                                                                                                                                                                                                                                                                                                        │',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
     it('should detect busy state for ctrl+c to stop pattern', () => {
         // Arrange
         terminal = createMockTerminal([
@@ -138,6 +153,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

@@ -20,6 +20,8 @@ export interface Session {
     worktreePath: string;
     sessionNumber: number;
     sessionName?: string;
+    command: string;
+    fallbackArgs?: string[];
     lastAccessedAt: number;
     process: IPty;
     output: string[];

package/dist/utils/hookExecutor.test.js

@@ -377,6 +377,8 @@ describe('hookExecutor Integration Tests', () => {
                 id: 'test-session-123',
                 worktreePath: tmpDir, // Use tmpDir as the worktree path
                 sessionNumber: 1,
+                command: 'claude',
+                fallbackArgs: undefined,
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
@@ -434,6 +436,8 @@ describe('hookExecutor Integration Tests', () => {
                 id: 'test-session-456',
                 worktreePath: tmpDir, // Use tmpDir as the worktree path
                 sessionNumber: 1,
+                command: 'claude',
+                fallbackArgs: undefined,
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
@@ -489,6 +493,8 @@ describe('hookExecutor Integration Tests', () => {
                 id: 'test-session-789',
                 worktreePath: tmpDir, // Use tmpDir as the worktree path
                 sessionNumber: 1,
+                command: 'claude',
+                fallbackArgs: undefined,
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
@@ -546,6 +552,8 @@ describe('hookExecutor Integration Tests', () => {
                 id: 'test-session-failure',
                 worktreePath: tmpDir,
                 sessionNumber: 1,
+                command: 'claude',
+                fallbackArgs: undefined,
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},

package/dist/utils/worktreeUtils.test.js

@@ -124,6 +124,8 @@ describe('prepareSessionItems', () => {
         id: 'test-session',
         worktreePath: '/path/to/worktree',
         sessionNumber: 1,
+        command: 'claude',
+        fallbackArgs: undefined,
         lastAccessedAt: Date.now(),
         process: {},
         output: [],

package/package.json

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