ccmanager 4.1.10 → 4.1.12

package/dist/components/App.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useState, useEffect, useCallback } from 'react';
-import { useApp, Box, Text } from 'ink';
+import { useApp, useInput, Box, Text } from 'ink';
 import { Effect } from 'effect';
 import Menu from './Menu.js';
 import Dashboard from './Dashboard.js';
@@ -31,6 +31,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     const [worktreeService, setWorktreeService] = useState(() => new WorktreeService());
     const [activeSession, setActiveSession] = useState(null);
     const [error, setError] = useState(null);
+    const [worktreeHookError, setWorktreeHookError] = useState(null);
     const [menuKey, setMenuKey] = useState(0); // Force menu refresh
     const [selectedWorktree, setSelectedWorktree] = useState(null); // Store selected worktree for preset selection
     const [renameTarget, setRenameTarget] = useState(null);
@@ -44,6 +45,26 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     const [loadingContext, setLoadingContext] = useState({});
     // State for streaming devcontainer up logs
     const [devcontainerLogs, setDevcontainerLogs] = useState([]);
+    const [canReturnFromHookError, setCanReturnFromHookError] = useState(false);
+    useEffect(() => {
+        if (view !== 'worktree-hook-error') {
+            setCanReturnFromHookError(false);
+            return;
+        }
+        const timeout = setTimeout(() => {
+            setCanReturnFromHookError(true);
+        }, 100);
+        return () => {
+            clearTimeout(timeout);
+        };
+    }, [view]);
+    useInput(() => {
+        if (view !== 'worktree-hook-error' || !canReturnFromHookError) {
+            return;
+        }
+        setWorktreeHookError(null);
+        handleReturnToMenu();
+    });
     // Helper function to format error messages based on error type using _tag discrimination
     const formatErrorMessage = (error) => {
         switch (error._tag) {
@@ -59,6 +80,10 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
                 return `Validation failed for ${error.field}: ${error.constraint}`;
         }
     };
+    const formatPostCreationHookWarning = (error) => `Post-creation hook failed: ${error.message}`;
+    const formatPreCreationHookError = (error) => error._tag === 'ProcessError'
+        ? `Pre-creation hook failed: ${error.message}`
+        : formatErrorMessage(error);
     // Helper function to create session with Effect-based error handling
     const createSessionWithEffect = useCallback(async (worktreePath, presetId, initialPrompt) => {
         setDevcontainerLogs([]);
@@ -218,6 +243,12 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     // Helper function to handle worktree creation results
     const handleWorktreeCreationResult = (result, creationData) => {
         if (result.success) {
+            if (result.warning) {
+                setError(null);
+                setWorktreeHookError(result.warning);
+                setView('worktree-hook-error');
+                return;
+            }
             if (creationData.presetId && creationData.initialPrompt) {
                 setPendingMenuSessionLaunch({
                     worktree: {
@@ -381,7 +412,13 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         // Transform Effect result to legacy format for handleWorktreeCreationResult
         if (result._tag === 'Left') {
             // Handle error using pattern matching on _tag
-            const errorMessage = formatErrorMessage(result.left);
+            const errorMessage = formatPreCreationHookError(result.left);
+            if (result.left._tag === 'ProcessError') {
+                setError(null);
+                setWorktreeHookError(errorMessage);
+                setView('worktree-hook-error');
+                return;
+            }
             handleWorktreeCreationResult({ success: false, error: errorMessage }, {
                 path: targetPath,
                 branch,
@@ -396,8 +433,13 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         }
         else {
             // Success case
-            const createdWorktree = result.right;
-            handleWorktreeCreationResult({ success: true }, {
+            const { worktree: createdWorktree, postCreationHookError } = result.right;
+            handleWorktreeCreationResult({
+                success: true,
+                warning: postCreationHookError
+                    ? formatPostCreationHookWarning(postCreationHookError)
+                    : undefined,
+            }, {
                 path: createdWorktree.path,
                 branch: createdWorktree.branch || branch,
                 baseBranch: request.baseBranch,
@@ -432,14 +474,26 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         creationData.copySessionData, creationData.copyClaudeDirectory)));
         if (result._tag === 'Left') {
             // Handle error using pattern matching on _tag
-            const errorMessage = formatErrorMessage(result.left);
+            const errorMessage = formatPreCreationHookError(result.left);
+            if (result.left._tag === 'ProcessError') {
+                setError(null);
+                setWorktreeHookError(errorMessage);
+                setView('worktree-hook-error');
+                return;
+            }
             setError(errorMessage);
             setView('new-worktree');
         }
         else {
-            handleWorktreeCreationResult({ success: true }, {
-                path: creationData.path,
-                branch: creationData.branch,
+            const { worktree: createdWorktree, postCreationHookError } = result.right;
+            handleWorktreeCreationResult({
+                success: true,
+                warning: postCreationHookError
+                    ? formatPostCreationHookWarning(postCreationHookError)
+                    : undefined,
+            }, {
+                path: createdWorktree.path,
+                branch: createdWorktree.branch || creationData.branch,
                 baseBranch: selectedRemoteRef,
                 copySessionData: creationData.copySessionData,
                 copyClaudeDirectory: creationData.copyClaudeDirectory,
@@ -555,6 +609,9 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
                 : 'Creating worktree...';
         return (_jsx(Box, { flexDirection: "column", children: _jsx(LoadingSpinner, { message: message, color: "cyan" }) }));
     }
+    if (view === 'worktree-hook-error') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "red", children: "Worktree hook error" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "red", children: worktreeHookError }) }), _jsx(Text, { dimColor: true, children: "Press any key to return to the menu" })] }));
+    }
     if (view === 'delete-worktree') {
         return (_jsxs(Box, { flexDirection: "column", children: [error && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), _jsx(DeleteWorktree, { projectPath: selectedProject?.path, onComplete: handleDeleteWorktrees, onCancel: handleCancelDeleteWorktree })] }));
     }

package/dist/components/App.test.js

@@ -3,6 +3,7 @@ import { render } from 'ink-testing-library';
 import { beforeAll, beforeEach, afterEach, describe, expect, it, vi, } from 'vitest';
 import { Effect } from 'effect';
 import { ENV_VARS } from '../constants/env.js';
+import { ProcessError } from '../types/errors.js';
 let App;
 let menuProps;
 let newWorktreeProps;
@@ -129,10 +130,12 @@ beforeEach(() => {
     createWorktreeEffectMock.mockReset();
     deleteWorktreeEffectMock.mockReset();
     createWorktreeEffectMock.mockImplementation((path, branch) => Effect.succeed({
-        path,
-        branch,
-        isMainWorktree: false,
-        hasSession: false,
+        worktree: {
+            path,
+            branch,
+            isMainWorktree: false,
+            hasSession: false,
+        },
     }));
     deleteWorktreeEffectMock.mockImplementation(() => Effect.succeed(undefined));
     sessionManagers.length = 0;
@@ -171,10 +174,12 @@ describe('App component loading state machine', () => {
         createWorktreeEffectMock.mockImplementation(() => Effect.tryPromise({
             try: () => new Promise(resolve => {
                 resolveWorktree = () => resolve({
-                    path: '/tmp/test',
-                    branch: 'feature',
-                    isMainWorktree: false,
-                    hasSession: false,
+                    worktree: {
+                        path: '/tmp/test',
+                        branch: 'feature',
+                        isMainWorktree: false,
+                        hasSession: false,
+                    },
                 });
             }),
             catch: (error) => error,
@@ -228,12 +233,147 @@ describe('App component loading state machine', () => {
         expect(sessionProps?.session).toEqual(mockSession);
         unmount();
     });
+    it('shows a hook error screen before returning to menu when post-creation hook fails after manual worktree creation', async () => {
+        createWorktreeEffectMock.mockImplementation((path, branch) => Effect.succeed({
+            worktree: {
+                path,
+                branch,
+                isMainWorktree: false,
+                hasSession: false,
+            },
+            postCreationHookError: new ProcessError({
+                command: 'exit 1',
+                exitCode: 1,
+                message: 'Hook exited with code 1',
+            }),
+        }));
+        const { lastFrame, stdin, unmount } = render(_jsx(App, { version: "test" }));
+        await waitForCondition(() => Boolean(menuProps));
+        await Promise.resolve(menuProps.onMenuAction({ type: 'newWorktree' }));
+        await waitForCondition(() => Boolean(newWorktreeProps));
+        await Promise.resolve(newWorktreeProps.onComplete({
+            creationMode: 'manual',
+            path: '/tmp/test',
+            branch: 'feature',
+            baseBranch: 'main',
+            copySessionData: false,
+            copyClaudeDirectory: false,
+        }));
+        await waitForCondition(() => lastFrame()?.includes('Worktree hook error') ?? false);
+        expect(lastFrame()).toContain('Post-creation hook failed');
+        expect(lastFrame()).toContain('Hook exited with code 1');
+        expect(lastFrame()).toContain('Press any key to return to the menu');
+        await flush(120);
+        stdin.write('x');
+        await waitForCondition(() => lastFrame()?.includes('Menu View') ?? false);
+        unmount();
+    });
+    it('shows a hook error screen before returning to menu when pre-creation hook fails', async () => {
+        createWorktreeEffectMock.mockImplementation(() => Effect.fail(new ProcessError({
+            command: 'exit 1',
+            exitCode: 1,
+            message: 'Hook exited with code 1',
+        })));
+        const { lastFrame, stdin, unmount } = render(_jsx(App, { version: "test" }));
+        await waitForCondition(() => Boolean(menuProps));
+        await Promise.resolve(menuProps.onMenuAction({ type: 'newWorktree' }));
+        await waitForCondition(() => Boolean(newWorktreeProps));
+        await Promise.resolve(newWorktreeProps.onComplete({
+            creationMode: 'manual',
+            path: '/tmp/test',
+            branch: 'feature',
+            baseBranch: 'main',
+            copySessionData: false,
+            copyClaudeDirectory: false,
+        }));
+        await waitForCondition(() => lastFrame()?.includes('Worktree hook error') ?? false);
+        expect(lastFrame()).toContain('Pre-creation hook failed');
+        expect(lastFrame()).toContain('Hook exited with code 1');
+        expect(lastFrame()).toContain('Press any key to return to the menu');
+        await flush(120);
+        stdin.write('x');
+        await waitForCondition(() => lastFrame()?.includes('Menu View') ?? false);
+        unmount();
+    });
+    it('ignores immediate input on the hook error screen so the error remains visible', async () => {
+        createWorktreeEffectMock.mockImplementation((path, branch) => Effect.succeed({
+            worktree: {
+                path,
+                branch,
+                isMainWorktree: false,
+                hasSession: false,
+            },
+            postCreationHookError: new ProcessError({
+                command: 'exit 1',
+                exitCode: 1,
+                message: 'Hook exited with code 1',
+            }),
+        }));
+        const { lastFrame, stdin, unmount } = render(_jsx(App, { version: "test" }));
+        await waitForCondition(() => Boolean(menuProps));
+        await Promise.resolve(menuProps.onMenuAction({ type: 'newWorktree' }));
+        await waitForCondition(() => Boolean(newWorktreeProps));
+        await Promise.resolve(newWorktreeProps.onComplete({
+            creationMode: 'manual',
+            path: '/tmp/test',
+            branch: 'feature',
+            baseBranch: 'main',
+            copySessionData: false,
+            copyClaudeDirectory: false,
+        }));
+        await waitForCondition(() => lastFrame()?.includes('Worktree hook error') ?? false);
+        stdin.write('x');
+        await flush(40);
+        expect(lastFrame()).toContain('Worktree hook error');
+        expect(lastFrame()).toContain('Hook exited with code 1');
+        await flush(120);
+        stdin.write('x');
+        await waitForCondition(() => lastFrame()?.includes('Menu View') ?? false);
+        unmount();
+    });
+    it('does not auto-start a prompt-first session when post-creation hook fails', async () => {
+        createWorktreeEffectMock.mockImplementation((path, branch) => Effect.succeed({
+            worktree: {
+                path,
+                branch,
+                isMainWorktree: false,
+                hasSession: false,
+            },
+            postCreationHookError: new ProcessError({
+                command: 'exit 1',
+                exitCode: 1,
+                message: 'Hook exited with code 1',
+            }),
+        }));
+        const { lastFrame, unmount } = render(_jsx(App, { version: "test" }));
+        await waitForCondition(() => Boolean(menuProps));
+        const sessionManager = sessionManagers[0];
+        await Promise.resolve(menuProps.onMenuAction({ type: 'newWorktree' }));
+        await waitForCondition(() => Boolean(newWorktreeProps));
+        await Promise.resolve(newWorktreeProps.onComplete({
+            creationMode: 'prompt',
+            path: '/tmp/project',
+            projectPath: '/tmp/project',
+            autoDirectoryPattern: '../{branch}',
+            baseBranch: 'main',
+            presetId: 'claude',
+            initialPrompt: 'trim worktree name output',
+            copySessionData: false,
+            copyClaudeDirectory: false,
+        }));
+        await waitForCondition(() => lastFrame()?.includes('Worktree hook error') ?? false);
+        expect(sessionManager.createSessionWithPresetEffect).not.toHaveBeenCalled();
+        expect(lastFrame()).toContain('Post-creation hook failed');
+        unmount();
+    });
     it('uses the created worktree path when auto-starting a prompt-first session', async () => {
         createWorktreeEffectMock.mockImplementation((_path, branch) => Effect.succeed({
-            path: '/tmp/resolved-worktree',
-            branch,
-            isMainWorktree: false,
-            hasSession: false,
+            worktree: {
+                path: '/tmp/resolved-worktree',
+                branch,
+                isMainWorktree: false,
+                hasSession: false,
+            },
         }));
         const { unmount } = render(_jsx(App, { version: "test" }));
         await waitForCondition(() => Boolean(menuProps));

package/dist/services/sessionManager.d.ts

@@ -18,8 +18,6 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private autoApprovalDisabledWorktrees;
     private restoringSessions;
     private bufferedRestoreData;
-    private restoreRefreshTimers;
-    private restoreRefreshDeadlines;
     private spawn;
     private resolvePreset;
     detectTerminalState(session: Session): SessionState;
@@ -41,10 +39,6 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private createTerminal;
     private shouldResetRestoreScrollback;
     private getRestoreSnapshot;
-    private scheduleRestoreRefresh;
-    private armRestoreRefreshTimer;
-    private cancelRestoreRefresh;
-    private fireRestoreRefresh;
     private createSessionInternal;
     /**
      * Create session with command preset using Effect-based error handling

package/dist/services/sessionManager.js

@@ -21,15 +21,6 @@ const { Terminal } = pkg;
 const TERMINAL_CONTENT_MAX_LINES = 300;
 const TERMINAL_SCROLLBACK_LINES = 5000;
 const TERMINAL_RESTORE_SCROLLBACK_LINES = 200;
-// Claude Code's Ink-based renderer sometimes splits a single UI redraw across
-// multiple PTY writes with short time gaps. If we snapshot between chunks, the
-// resulting viewport can miss rows (e.g. empty middle area while the top/bottom
-// chrome already rendered). Re-emit the snapshot after the PTY output has been
-// quiet for this long so late chunks are accounted for.
-const RESTORE_REFRESH_QUIET_MS = 120;
-// Cap on how long we wait for quiet before forcing the refresh, so continuous
-// streaming output (e.g. a long busy turn) still produces an updated snapshot.
-const RESTORE_REFRESH_MAX_WAIT_MS = 400;
 export class SessionManager extends EventEmitter {
     sessions;
     waitingWithBottomBorder = new Map();
@@ -37,8 +28,6 @@ export class SessionManager extends EventEmitter {
     autoApprovalDisabledWorktrees = new Set();
     restoringSessions = new Set();
     bufferedRestoreData = new Map();
-    restoreRefreshTimers = new Map();
-    restoreRefreshDeadlines = new Map();
     async spawn(command, args, worktreePath, options = {}) {
         const spawnOptions = {
             name: 'xterm-256color',
@@ -216,7 +205,7 @@ export class SessionManager extends EventEmitter {
             data.includes('\x1b[3J') ||
             data.includes('\x1bc'));
     }
-    getRestoreSnapshot(session, options = {}) {
+    getRestoreSnapshot(session) {
         const activeBuffer = session.terminal.buffer.active;
         if (activeBuffer.type !== 'normal') {
             return session.serializer.serialize({
@@ -228,22 +217,6 @@ export class SessionManager extends EventEmitter {
         if (bufferLength === 0) {
             return '';
         }
-        // While the session is busy, cursor-addressed status-box redraws can push
-        // stale frames into scrollback (e.g. Claude's spinner + token stats line).
-        // Those ghost rows render as duplicated status bars when replayed, so
-        // restore only the viewport during busy state. Refresh re-emits also
-        // bypass scrollback to avoid duplicating history into real-terminal
-        // scrollback on top of the initial emit.
-        const isBusy = session.stateMutex.getSnapshot().state === 'busy';
-        if (options.viewportOnly || isBusy) {
-            const snapshot = session.serializer.serialize({
-                scrollback: 0,
-                excludeAltBuffer: true,
-            });
-            const cursorRow = normalBuffer.cursorY + 1;
-            const cursorCol = normalBuffer.cursorX + 1;
-            return `${snapshot}\x1b[${cursorRow};${cursorCol}H`;
-        }
         const scrollbackStart = Math.max(0, normalBuffer.baseY - TERMINAL_RESTORE_SCROLLBACK_LINES);
         const rangeStart = Math.max(session.restoreScrollbackBaseLine, scrollbackStart);
         const rangeEnd = bufferLength - 1;
@@ -258,56 +231,6 @@ export class SessionManager extends EventEmitter {
         const cursorCol = normalBuffer.cursorX + 1;
         return `${snapshot}\x1b[${cursorRow};${cursorCol}H`;
     }
-    scheduleRestoreRefresh(session) {
-        this.restoreRefreshDeadlines.set(session.id, Date.now() + RESTORE_REFRESH_MAX_WAIT_MS);
-        this.armRestoreRefreshTimer(session);
-    }
-    armRestoreRefreshTimer(session) {
-        const deadline = this.restoreRefreshDeadlines.get(session.id);
-        if (deadline === undefined) {
-            return;
-        }
-        const existing = this.restoreRefreshTimers.get(session.id);
-        if (existing !== undefined) {
-            clearTimeout(existing);
-            this.restoreRefreshTimers.delete(session.id);
-        }
-        const remaining = deadline - Date.now();
-        if (remaining <= 0) {
-            this.fireRestoreRefresh(session);
-            return;
-        }
-        const delay = Math.min(RESTORE_REFRESH_QUIET_MS, remaining);
-        const timer = setTimeout(() => this.fireRestoreRefresh(session), delay);
-        this.restoreRefreshTimers.set(session.id, timer);
-    }
-    cancelRestoreRefresh(session) {
-        const existing = this.restoreRefreshTimers.get(session.id);
-        if (existing !== undefined) {
-            clearTimeout(existing);
-            this.restoreRefreshTimers.delete(session.id);
-        }
-        this.restoreRefreshDeadlines.delete(session.id);
-    }
-    fireRestoreRefresh(session) {
-        this.restoreRefreshTimers.delete(session.id);
-        this.restoreRefreshDeadlines.delete(session.id);
-        if (!session.isActive) {
-            return;
-        }
-        const snapshot = this.getRestoreSnapshot(session, { viewportOnly: true });
-        if (snapshot.length > 0) {
-            // \x1b[2J: clear the viewport before repainting — without this, a
-            //   refresh snapshot shorter than the already-displayed content leaves
-            //   a "ghost tail" of pre-refresh rows at the bottom.
-            // \x1b[?7h / \x1b[?7l: Session.tsx disables auto-wrap (DECAWM) after
-            //   the initial restore, but SerializeAddon omits row separators for
-            //   wrapped lines and relies on DECAWM to advance to the next row
-            //   (see PR #276). Re-enable auto-wrap just for the snapshot write so
-            //   wrapped viewport rows don't overlap, then restore the TUI default.
-            this.emit('sessionRestore', session, `\x1b[?7h\x1b[2J\x1b[H${snapshot}\x1b[?7l`);
-        }
-    }
     async createSessionInternal(worktreePath, ptyProcess, options = {}) {
         const existingSessions = this.getSessionsForWorktree(worktreePath);
         const maxNumber = existingSessions.reduce((max, s) => Math.max(max, s.sessionNumber), 0);
@@ -411,12 +334,6 @@ export class SessionManager extends EventEmitter {
                     session.terminal.buffer.normal.baseY;
             }
             session.lastActivity = new Date();
-            // If a restore-refresh is pending, each incoming chunk resets the
-            // quiet timer so the follow-up snapshot only fires after Claude's
-            // multi-chunk redraw has settled.
-            if (this.restoreRefreshDeadlines.has(session.id)) {
-                this.armRestoreRefreshTimer(session);
-            }
             // Only emit data events when session is active
             if (session.isActive) {
                 if (this.restoringSessions.has(session.id)) {
@@ -576,12 +493,10 @@ export class SessionManager extends EventEmitter {
                         }
                     }
                 }
-                this.scheduleRestoreRefresh(session);
             }
             else {
                 this.restoringSessions.delete(session.id);
                 this.bufferedRestoreData.delete(session.id);
-                this.cancelRestoreRefresh(session);
             }
         }
     }
@@ -656,7 +571,6 @@ export class SessionManager extends EventEmitter {
             this.waitingWithBottomBorder.delete(sessionId);
             this.restoringSessions.delete(sessionId);
             this.bufferedRestoreData.delete(sessionId);
-            this.cancelRestoreRefresh(session);
             this.emit('sessionDestroyed', session);
         }
     }
@@ -710,7 +624,6 @@ export class SessionManager extends EventEmitter {
                 }
                 this.sessions.delete(sessionId);
                 this.waitingWithBottomBorder.delete(sessionId);
-                this.cancelRestoreRefresh(session);
                 this.emit('sessionDestroyed', session);
             },
             catch: (error) => {

package/dist/services/sessionManager.test.js

@@ -782,7 +782,6 @@ describe('SessionManager', () => {
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
             const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-            await session.stateMutex.update(data => ({ ...data, state: 'idle' }));
             const normalBuffer = session.terminal.buffer.normal;
             normalBuffer.baseY = 260;
             normalBuffer.length = 300;
@@ -804,32 +803,6 @@ describe('SessionManager', () => {
             });
             expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mrestored\u001b[0m\u001b[8;12H');
         });
-        it('should emit a viewport-only restore snapshot while session is busy', async () => {
-            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
-                id: '1',
-                name: 'Main',
-                command: 'claude',
-            });
-            vi.mocked(spawn).mockReturnValue(mockPty);
-            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-            const normalBuffer = session.terminal.buffer.normal;
-            normalBuffer.baseY = 260;
-            normalBuffer.length = 300;
-            normalBuffer.cursorY = 7;
-            normalBuffer.cursorX = 11;
-            session.restoreScrollbackBaseLine = 120;
-            const serializeMock = vi
-                .spyOn(session.serializer, 'serialize')
-                .mockReturnValue('\u001b[31mbusy-viewport\u001b[0m');
-            const restoreHandler = vi.fn();
-            sessionManager.on('sessionRestore', restoreHandler);
-            sessionManager.setSessionActive(session.id, true);
-            expect(serializeMock).toHaveBeenCalledWith({
-                scrollback: 0,
-                excludeAltBuffer: true,
-            });
-            expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mbusy-viewport\u001b[0m\u001b[8;12H');
-        });
         it('should keep viewport-only restore behavior for alternate screen sessions', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -899,90 +872,6 @@ describe('SessionManager', () => {
             sessionManager.setSessionActive(session.id, true);
             expect(eventOrder).toEqual(['restore', 'data']);
         });
-        it('should re-emit a viewport-only snapshot after the PTY quiet period', async () => {
-            vi.useFakeTimers();
-            try {
-                vi.mocked(configReader.getDefaultPreset).mockReturnValue({
-                    id: '1',
-                    name: 'Main',
-                    command: 'claude',
-                });
-                vi.mocked(spawn).mockReturnValue(mockPty);
-                const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-                session.terminal.buffer.normal.length = 1;
-                const serializeMock = vi
-                    .spyOn(session.serializer, 'serialize')
-                    .mockReturnValue('snap');
-                const restoreHandler = vi.fn();
-                sessionManager.on('sessionRestore', restoreHandler);
-                sessionManager.setSessionActive(session.id, true);
-                expect(restoreHandler).toHaveBeenCalledTimes(1);
-                await vi.advanceTimersByTimeAsync(50);
-                mockPty.emit('data', 'late-chunk');
-                await vi.advanceTimersByTimeAsync(50);
-                expect(restoreHandler).toHaveBeenCalledTimes(1);
-                await vi.advanceTimersByTimeAsync(120);
-                expect(restoreHandler).toHaveBeenCalledTimes(2);
-                expect(restoreHandler.mock.calls[1]?.[1]).toMatch(/^\u001b\[\?7h\u001b\[2J\u001b\[Hsnap.*\u001b\[\?7l$/);
-                expect(serializeMock).toHaveBeenLastCalledWith({
-                    scrollback: 0,
-                    excludeAltBuffer: true,
-                });
-            }
-            finally {
-                vi.useRealTimers();
-            }
-        });
-        it('should force a refresh at the max-wait deadline even while data keeps streaming', async () => {
-            vi.useFakeTimers();
-            try {
-                vi.mocked(configReader.getDefaultPreset).mockReturnValue({
-                    id: '1',
-                    name: 'Main',
-                    command: 'claude',
-                });
-                vi.mocked(spawn).mockReturnValue(mockPty);
-                const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-                session.terminal.buffer.normal.length = 1;
-                vi.spyOn(session.serializer, 'serialize').mockReturnValue('snap');
-                const restoreHandler = vi.fn();
-                sessionManager.on('sessionRestore', restoreHandler);
-                sessionManager.setSessionActive(session.id, true);
-                expect(restoreHandler).toHaveBeenCalledTimes(1);
-                for (let elapsed = 0; elapsed < 400; elapsed += 50) {
-                    await vi.advanceTimersByTimeAsync(50);
-                    mockPty.emit('data', 'chunk');
-                }
-                expect(restoreHandler).toHaveBeenCalledTimes(2);
-            }
-            finally {
-                vi.useRealTimers();
-            }
-        });
-        it('should cancel a scheduled refresh when the session is deactivated', async () => {
-            vi.useFakeTimers();
-            try {
-                vi.mocked(configReader.getDefaultPreset).mockReturnValue({
-                    id: '1',
-                    name: 'Main',
-                    command: 'claude',
-                });
-                vi.mocked(spawn).mockReturnValue(mockPty);
-                const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-                session.terminal.buffer.normal.length = 1;
-                vi.spyOn(session.serializer, 'serialize').mockReturnValue('snap');
-                const restoreHandler = vi.fn();
-                sessionManager.on('sessionRestore', restoreHandler);
-                sessionManager.setSessionActive(session.id, true);
-                expect(restoreHandler).toHaveBeenCalledTimes(1);
-                sessionManager.setSessionActive(session.id, false);
-                await vi.advanceTimersByTimeAsync(500);
-                expect(restoreHandler).toHaveBeenCalledTimes(1);
-            }
-            finally {
-                vi.useRealTimers();
-            }
-        });
     });
     describe('static methods', () => {
         describe('getSessionCounts', () => {

package/dist/services/stateDetector/codex.js

@@ -15,7 +15,8 @@ export class CodexStateDetector extends BaseStateDetector {
         // Check for waiting prompts
         if (lowerContent.includes('allow command?') ||
             lowerContent.includes('[y/n]') ||
-            lowerContent.includes('yes (y)')) {
+            lowerContent.includes('yes (y)') ||
+            lowerContent.includes('enter to submit')) {
             return 'waiting_input';
         }
         if (/(do you want|would you like)[\s\S]*?\n+[\s\S]*?\byes\b/.test(lowerContent)) {

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

@@ -171,4 +171,24 @@ describe('CodexStateDetector', () => {
         // Assert
         expect(state).toBe('waiting_input');
     });
+    it('should detect waiting_input for MCP tool permission prompt with "enter to submit"', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Field 1/1',
+            'Allow the chrome-devtools MCP server to run tool "new_page"?',
+            '',
+            'timeout: 10000',
+            'url: http://localhost:4000/scenarios',
+            '',
+            '› 1. Allow                   Run the tool and continue.',
+            '2. Allow for this session  Run the tool and remember this choice for this session.',
+            '3. Always allow            Run the tool and remember this choice for future tool calls.',
+            '4. Cancel                  Cancel this tool call',
+            'enter to submit | esc to cancel',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
 });

package/dist/services/worktreeService.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from 'effect';
-import { Worktree, MergeConfig } from '../types/index.js';
+import { Worktree, CreateWorktreeResult, MergeConfig } from '../types/index.js';
 import { GitError, FileSystemError, ProcessError } from '../types/errors.js';
 /**
  * WorktreeService - Git worktree management with Effect-based error handling
@@ -323,7 +323,7 @@ export declare class WorktreeService {
      * @throws {GitError} When git worktree add command fails
      * @throws {FileSystemError} When session data copy fails
      */
-    createWorktreeEffect(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): Effect.Effect<Worktree, GitError | FileSystemError | ProcessError, never>;
+    createWorktreeEffect(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): Effect.Effect<CreateWorktreeResult, GitError | FileSystemError | ProcessError, never>;
     /**
      * Effect-based deleteWorktree operation
      * May fail with GitError

package/dist/services/worktreeService.js

@@ -8,6 +8,7 @@ import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
 import { getClaudeProjectsDir, pathToClaudeProjectName, } from '../utils/claudeDir.js';
 import { executeWorktreePostCreationHook, executeWorktreePreCreationHook, } from '../utils/hookExecutor.js';
 import { configReader } from './config/configReader.js';
+import { logger } from '../utils/logger.js';
 const CLAUDE_DIR = '.claude';
 /**
  * WorktreeService - Git worktree management with Effect-based error handling
@@ -764,6 +765,16 @@ export class WorktreeService {
             const resolvedPath = path.isAbsolute(worktreePath)
                 ? worktreePath
                 : path.join(absoluteGitRoot, worktreePath);
+            logger.info('Worktree creation requested', {
+                inputPath: worktreePath,
+                resolvedPath,
+                branch,
+                baseBranch,
+                rootPath: self.rootPath,
+                absoluteGitRoot,
+                copySessionData,
+                copyClaudeDirectory,
+            });
             // Check if branch exists
             const branchExists = yield* Effect.catchAll(Effect.try({
                 try: () => {
@@ -777,6 +788,12 @@ export class WorktreeService {
             }), () => Effect.succeed(false));
             // Execute pre-creation hook if configured (BEFORE git worktree add)
             const worktreeHooksConfig = configReader.getWorktreeHooks();
+            logger.info('Worktree hook config before creation', {
+                preCreationEnabled: Boolean(worktreeHooksConfig.pre_creation?.enabled),
+                preCreationCommand: worktreeHooksConfig.pre_creation?.command,
+                postCreationEnabled: Boolean(worktreeHooksConfig.post_creation?.enabled),
+                postCreationCommand: worktreeHooksConfig.post_creation?.command,
+            });
             if (worktreeHooksConfig.pre_creation?.enabled &&
                 worktreeHooksConfig.pre_creation?.command) {
                 yield* executeWorktreePreCreationHook(worktreeHooksConfig.pre_creation.command, resolvedPath, branch, absoluteGitRoot, baseBranch);
@@ -794,10 +811,18 @@ export class WorktreeService {
             // Execute the worktree creation command
             yield* Effect.try({
                 try: () => {
+                    logger.info('Executing git worktree add command', {
+                        command,
+                        cwd: absoluteGitRoot,
+                    });
                     execSync(command, {
                         cwd: absoluteGitRoot,
                         encoding: 'utf8',
                     });
+                    logger.info('Git worktree add command succeeded', {
+                        command,
+                        cwd: absoluteGitRoot,
+                    });
                 },
                 catch: (error) => {
                     const execError = error;
@@ -835,22 +860,31 @@ export class WorktreeService {
             }
             // Execute post-creation hook if configured
             const worktreeHooks = configReader.getWorktreeHooks();
-            if (worktreeHooks.post_creation?.enabled &&
-                worktreeHooks.post_creation?.command) {
-                const newWorktree = {
-                    path: resolvedPath,
-                    branch: branch,
-                    isMainWorktree: false,
-                    hasSession: false,
-                };
-                yield* executeWorktreePostCreationHook(worktreeHooks.post_creation.command, newWorktree, absoluteGitRoot, baseBranch);
-            }
-            return {
+            logger.info('Worktree hook config after creation', {
+                postCreationEnabled: Boolean(worktreeHooks.post_creation?.enabled),
+                postCreationCommand: worktreeHooks.post_creation?.command,
+                resolvedPath,
+                branch,
+            });
+            let postCreationHookError;
+            const createdWorktree = {
                 path: resolvedPath,
                 branch,
                 isMainWorktree: false,
                 hasSession: false,
             };
+            if (worktreeHooks.post_creation?.enabled &&
+                worktreeHooks.post_creation?.command) {
+                const postCreationHookResult = yield* Effect.either(executeWorktreePostCreationHook(worktreeHooks.post_creation.command, createdWorktree, absoluteGitRoot, baseBranch));
+                if (postCreationHookResult._tag === 'Left') {
+                    postCreationHookError = postCreationHookResult.left;
+                    logger.error(`Failed to execute post-creation hook: ${postCreationHookError.message}`);
+                }
+            }
+            return {
+                worktree: createdWorktree,
+                postCreationHookError,
+            };
         });
     }
     /**

package/dist/services/worktreeService.test.js

@@ -4,7 +4,7 @@ import { execSync } from 'child_process';
 import { existsSync, statSync } from 'fs';
 import { configReader } from './config/configReader.js';
 import { Effect } from 'effect';
-import { GitError } from '../types/errors.js';
+import { GitError, ProcessError } from '../types/errors.js';
 // Mock child_process module
 vi.mock('child_process');
 // Mock fs module
@@ -25,6 +25,7 @@ vi.mock('./config/configReader.js', () => ({
 }));
 // Mock HookExecutor
 vi.mock('../utils/hookExecutor.js', () => ({
+    executeWorktreePreCreationHook: vi.fn(),
     executeWorktreePostCreationHook: vi.fn(),
 }));
 // Get the mocked function with proper typing
@@ -641,7 +642,7 @@ branch refs/heads/feature
             });
             const effect = service.createWorktreeEffect('/path/to/worktree', 'new-feature', 'main');
             const result = await Effect.runPromise(effect);
-            expect(result).toMatchObject({
+            expect(result.worktree).toMatchObject({
                 path: '/path/to/worktree',
                 branch: 'new-feature',
                 isMainWorktree: false,
@@ -676,6 +677,77 @@ branch refs/heads/feature
                 expect.fail('Should have returned Left with GitError');
             }
         });
+        it('should fail with ProcessError and skip git worktree add when pre-creation hook fails', async () => {
+            const { executeWorktreePreCreationHook } = await import('../utils/hookExecutor.js');
+            const mockedPreHook = vi.mocked(executeWorktreePreCreationHook);
+            mockedGetWorktreeHooks.mockReturnValue({
+                pre_creation: {
+                    command: 'exit 1',
+                    enabled: true,
+                },
+            });
+            mockedPreHook.mockReturnValue(Effect.fail(new ProcessError({
+                command: 'exit 1',
+                exitCode: 1,
+                message: 'Hook exited with code 1',
+            })));
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        throw new Error('git worktree add should not be called');
+                    }
+                }
+                return '';
+            });
+            const result = await Effect.runPromise(Effect.either(service.createWorktreeEffect('/path/to/worktree', 'new-feature', 'main')));
+            expect(result._tag).toBe('Left');
+            if (result._tag === 'Left') {
+                expect(result.left).toBeInstanceOf(ProcessError);
+            }
+            expect(mockedExecSync).not.toHaveBeenCalledWith(expect.stringContaining('git worktree add'), expect.anything());
+        });
+        it('should return Worktree with postCreationHookError when post-creation hook fails', async () => {
+            const { executeWorktreePostCreationHook } = await import('../utils/hookExecutor.js');
+            const mockedPostHook = vi.mocked(executeWorktreePostCreationHook);
+            const hookError = new ProcessError({
+                command: 'exit 1',
+                exitCode: 1,
+                message: 'Hook exited with code 1',
+            });
+            mockedGetWorktreeHooks.mockReturnValue({
+                post_creation: {
+                    command: 'exit 1',
+                    enabled: true,
+                },
+            });
+            mockedPostHook.mockReturnValue(Effect.fail(hookError));
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                }
+                return '';
+            });
+            const result = await Effect.runPromise(service.createWorktreeEffect('/path/to/worktree', 'new-feature', 'main'));
+            expect(result.worktree).toMatchObject({
+                path: '/path/to/worktree',
+                branch: 'new-feature',
+            });
+            expect(result.postCreationHookError).toBe(hookError);
+        });
     });
     describe('Effect-based deleteWorktree', () => {
         it('should return Effect with void on success', async () => {

package/dist/types/errors.d.ts

@@ -51,6 +51,8 @@ export declare class ProcessError extends ProcessError_base<{
     readonly signal?: string;
     readonly exitCode?: number;
     readonly message: string;
+    readonly stdout?: string;
+    readonly stderr?: string;
 }> {
 }
 declare const ValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {

package/dist/types/index.d.ts

@@ -4,6 +4,7 @@ import type { SerializeAddon } from '@xterm/addon-serialize';
 import { GitStatus } from '../utils/gitStatus.js';
 import { Mutex, SessionStateData } from '../utils/mutex.js';
 import type { StateDetector } from '../services/stateDetector/types.js';
+import type { ProcessError } from './errors.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input' | 'pending_auto_approval';
 export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline' | 'opencode' | 'kimi';
@@ -16,6 +17,10 @@ export interface Worktree {
     gitStatusError?: string;
     lastCommitDate?: Date;
 }
+export interface CreateWorktreeResult {
+    worktree: Worktree;
+    postCreationHookError?: ProcessError;
+}
 export interface Session {
     id: string;
     worktreePath: string;
@@ -251,7 +256,7 @@ export declare class AmbiguousBranchError extends Error {
 export interface IWorktreeService {
     getWorktreesEffect(): import('effect').Effect.Effect<Worktree[], import('../types/errors.js').GitError, never>;
     getGitRootPath(): string;
-    createWorktreeEffect(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): import('effect').Effect.Effect<Worktree, import('../types/errors.js').GitError | import('../types/errors.js').FileSystemError | import('../types/errors.js').ProcessError, never>;
+    createWorktreeEffect(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): import('effect').Effect.Effect<CreateWorktreeResult, import('../types/errors.js').GitError | import('../types/errors.js').FileSystemError | import('../types/errors.js').ProcessError, never>;
     deleteWorktreeEffect(worktreePath: string, options?: {
         deleteBranch?: boolean;
     }): import('effect').Effect.Effect<void, import('../types/errors.js').GitError, never>;

package/dist/utils/hookExecutor.d.ts

@@ -59,7 +59,7 @@ export declare function executeWorktreePreCreationHook(command: string, worktree
  * Execute a worktree post-creation hook using Effect
  * Errors are caught and logged but do not break the main flow
  */
-export declare function executeWorktreePostCreationHook(command: string, worktree: Worktree, gitRoot: string, baseBranch?: string): Effect.Effect<void, never>;
+export declare function executeWorktreePostCreationHook(command: string, worktree: Worktree, gitRoot: string, baseBranch?: string): Effect.Effect<void, ProcessError>;
 /**
  * Execute a session status change hook using Effect
  * Errors are caught and logged but do not break the main flow

package/dist/utils/hookExecutor.js

@@ -4,6 +4,7 @@ import { Effect } from 'effect';
 import { ProcessError } from '../types/errors.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { configReader } from '../services/config/configReader.js';
+import { logger } from './logger.js';
 /**
  * Execute a hook command with the provided environment variables using Effect
  *
@@ -40,6 +41,11 @@ import { configReader } from '../services/config/configReader.js';
  */
 export function executeHook(command, cwd, environment) {
     return Effect.async(resume => {
+        logger.info('Hook execution starting', {
+            command,
+            cwd,
+            environment,
+        });
         // Use spawn with shell to execute the command and wait for all child processes
         const child = spawn(command, [], {
             cwd,
@@ -50,24 +56,44 @@ export function executeHook(command, cwd, environment) {
             shell: true,
             stdio: ['ignore', 'pipe', 'pipe'],
         });
+        let stdout = '';
         let stderr = '';
+        child.stdout?.on('data', data => {
+            stdout += data.toString();
+        });
         // Collect stderr for logging
         child.stderr?.on('data', data => {
             stderr += data.toString();
         });
         // Wait for the process and all its children to exit
         child.on('exit', (code, signal) => {
+            logger.info('Hook execution finished', {
+                command,
+                cwd,
+                exitCode: code,
+                signal,
+                stdout,
+                stderr,
+            });
             if (code !== 0 || signal) {
                 const errorMessage = signal
                     ? `Hook terminated by signal ${signal}`
                     : `Hook exited with code ${code}`;
+                const outputDetails = [
+                    stderr ? `Stderr: ${stderr}` : undefined,
+                    stdout ? `Stdout: ${stdout}` : undefined,
+                ]
+                    .filter(Boolean)
+                    .join('\n');
                 resume(Effect.fail(new ProcessError({
                     command,
                     exitCode: code ?? undefined,
                     signal: signal ?? undefined,
-                    message: stderr
-                        ? `${errorMessage}\nStderr: ${stderr}`
+                    message: outputDetails
+                        ? `${errorMessage}\n${outputDetails}`
                         : errorMessage,
+                    stdout,
+                    stderr,
                 })));
                 return;
             }
@@ -76,6 +102,11 @@ export function executeHook(command, cwd, environment) {
         });
         // Handle errors in spawning the process
         child.on('error', error => {
+            logger.error('Hook spawn failed', {
+                command,
+                cwd,
+                error: error.message,
+            });
             resume(Effect.fail(new ProcessError({
                 command,
                 message: error.message,
@@ -103,6 +134,13 @@ export function executeWorktreePreCreationHook(command, worktreePath, branch, gi
     if (baseBranch) {
         environment.CCMANAGER_BASE_BRANCH = baseBranch;
     }
+    logger.info('Worktree pre-creation hook configured', {
+        command,
+        worktreePath,
+        branch,
+        gitRoot,
+        baseBranch,
+    });
     // Execute in git root (worktree doesn't exist yet)
     // NO Effect.catchAll - errors must propagate to abort creation
     return executeHook(command, gitRoot, environment);
@@ -120,11 +158,14 @@ export function executeWorktreePostCreationHook(command, worktree, gitRoot, base
     if (baseBranch) {
         environment.CCMANAGER_BASE_BRANCH = baseBranch;
     }
-    return Effect.catchAll(executeHook(command, worktree.path, environment), error => {
-        // Log error but don't throw - hooks should not break the main flow
-        console.error(`Failed to execute post-creation hook: ${error.message}`);
-        return Effect.void;
+    logger.info('Worktree post-creation hook configured', {
+        command,
+        worktreePath: worktree.path,
+        branch: worktree.branch || 'unknown',
+        gitRoot,
+        baseBranch,
     });
+    return executeHook(command, worktree.path, environment);
 }
 /**
  * Execute a session status change hook using Effect

package/dist/utils/hookExecutor.test.js

@@ -156,7 +156,7 @@ describe('hookExecutor Integration Tests', () => {
         });
     });
     describe('executeWorktreePostCreationHook (real execution)', () => {
-        it('should not throw even when command fails', async () => {
+        it('should fail with ProcessError when command fails', async () => {
             // Arrange
             const tmpDir = await mkdtemp(join(tmpdir(), 'hook-test-'));
             const worktree = {
@@ -166,8 +166,13 @@ describe('hookExecutor Integration Tests', () => {
                 hasSession: false,
             };
             try {
-                // Act & Assert - should not throw even with failing command
-                await expect(Effect.runPromise(executeWorktreePostCreationHook('exit 1', worktree, tmpDir, 'main'))).resolves.toBeUndefined();
+                // Act & Assert - post-creation hook failures are surfaced to callers
+                const result = await Effect.runPromise(Effect.either(executeWorktreePostCreationHook('exit 1', worktree, tmpDir, 'main')));
+                expect(result._tag).toBe('Left');
+                if (result._tag === 'Left') {
+                    expect(result.left._tag).toBe('ProcessError');
+                    expect(result.left.exitCode).toBe(1);
+                }
             }
             finally {
                 // Cleanup

package/dist/utils/logger.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { format } from 'util';
-import os from 'os';
+import * as os from 'os';
 /**
  * Log level constants for structured logging
  */

package/package.json

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