ccmanager 4.1.10 → 4.1.11

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/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.11",
 	"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.11",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.11",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.11",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.1.11",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.1.11"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",